@tangle-network/agent-eval 0.217.1 → 0.218.1

package/dist/{skillopt-optimization-method-kyL94-ri.js → skillopt-optimization-method-5dlex7MJ.js}

@@ -3,17 +3,17 @@ import { t as mean$1 } from "./mean-BbA_JCzW.js";
 import { t as decidePairedPromotion } from "./paired-promotion-decision-D0SHb-ZL.js";
 import { a as heldoutSignificance, o as pairHoldout } from "./statistical-heldout-Bksv92Th.js";
 import { n as contentHash, t as canonicalJson } from "./verdict-cache-CL_7tePD.js";
-import { E as assertSearchHistoryAdmissionOptions, J as evaluationUnitMap, K as assertIndependentEvaluationSplit, Q as runCampaign, S as developmentClaim, T as surfaceNode, X as reserveFinalEvidence, Y as exposeFinalEvidence, c as assertGepaCandidatePopulationSummary, d as costFromLedgerSummary, et as resolveRunDir, f as optimizationTokenUsageFromSummary, l as readGepaCandidatePopulationArtifact, q as captureFinalEvidencePolicy, s as executeOptimizationMethod, u as combineComparisonCosts, w as surfaceDiff, x as SearchRecorder, z as captureJudge } from "./llm-judge-C8jMTNNG.js";
-import { D as surfaceContentHash, I as assertCompleteCampaign, P as assertCampaignDesign, f as campaignBreakdown, t as createCampaignEvidenceReceipt } from "./campaign-evidence-CQYw8_0H.js";
-import { a as mapConcurrent } from "./journal-CR4QikYp.js";
+import { E as assertSearchHistoryAdmissionOptions, J as evaluationUnitMap, K as assertIndependentEvaluationSplit, Q as runCampaign, S as developmentClaim, T as surfaceNode, X as reserveFinalEvidence, Y as exposeFinalEvidence, c as assertGepaCandidatePopulationSummary, d as costFromLedgerSummary, et as resolveRunDir, f as optimizationTokenUsageFromSummary, l as readGepaCandidatePopulationArtifact, q as captureFinalEvidencePolicy, s as executeOptimizationMethod, u as combineComparisonCosts, w as surfaceDiff, x as SearchRecorder, z as captureJudge } from "./llm-judge-Djxh-Uhs.js";
+import { D as surfaceContentHash, I as assertCompleteCampaign, P as assertCampaignDesign, f as campaignBreakdown, t as createCampaignEvidenceReceipt } from "./campaign-evidence-DunzcJGv.js";
+import { a as mapConcurrent } from "./journal-C7om8Gum.js";
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
-import { M as fsCampaignStorage, _ as resolveExternalOptimizerCallbackLimits, d as assertExternalOptimizerModelBudget, f as assertJsonValue, g as removeCredentialEnvironment, h as isExternalTextCandidate, i as startExternalOptimizerModelProxy, j as createRunCostLedger, m as isCandidateText, n as closeExternalOptimizerResources, p as assertNoCredentialValues, r as runWithCleanup, t as runExternalOptimizerProcess, v as resolveExternalOptimizerProcessLimits, y as safePathComponent } from "./external-optimizer-subprocess-XIHBOSKt.js";
+import { M as fsCampaignStorage, _ as resolveExternalOptimizerCallbackLimits, d as assertExternalOptimizerModelBudget, f as assertJsonValue, g as removeCredentialEnvironment, h as isExternalTextCandidate, i as startExternalOptimizerModelProxy, j as createRunCostLedger, m as isCandidateText, n as closeExternalOptimizerResources, p as assertNoCredentialValues, r as runWithCleanup, t as runExternalOptimizerProcess, v as resolveExternalOptimizerProcessLimits, y as safePathComponent } from "./external-optimizer-subprocess-B5gdLRZv.js";
 import { r as summarizeEvaluationUnits, t as defineEvaluationClaim } from "./claim-BPVuyHuy.js";
-import { n as openSearchLedger } from "./search-ledger-TUvB5gWH.js";
-import { t as acquireSingleRunLock } from "./single-run-lock-U58yf8N6.js";
+import { n as openSearchLedger } from "./search-ledger-ClpN4I3e.js";
+import { t as acquireSingleRunLock } from "./single-run-lock-Dekd8_Wv.js";
 import { n as isRecord } from "./json-BhdsJaOQ.js";
-import { _ as combineAbortSignals, d as assertServedModelPolicy } from "./llm-client-BshCREn6.js";
-import { t as startExternalOptimizerCallback } from "./external-optimizer-process-KVFGvYX1.js";
+import { _ as combineAbortSignals, d as assertServedModelPolicy } from "./llm-client-_Y6ic-tf.js";
+import { t as startExternalOptimizerCallback } from "./external-optimizer-process-C3Wm7Vhn.js";
 import { createHash, randomBytes } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
@@ -567,270 +567,341 @@ function externalTextOptimizationMethod(config) {
 	const snapshot = snapshotExternalTextOptimizationConfig(config);
 	return {
 		name: snapshot.name,
-		async optimize(input) {
-			const seedCandidate = encodeExternalTextCandidate(input.baselineSurface);
-			const expectsComponents = typeof seedCandidate !== "string";
-			const maxCandidateChars = snapshot.maxCandidateChars ?? DEFAULT_MAX_CANDIDATE_CHARS;
-			const maxEvidenceChars = snapshot.maxEvidenceChars ?? DEFAULT_MAX_EVIDENCE_CHARS;
-			const attemptId = randomBytes(16).toString("hex");
-			const storage = input.runOptions.storage ?? fsCampaignStorage();
-			const resume = snapshot.resume ?? "never";
-			const trainSet = Object.freeze(input.trainScenarios.map((scenario) => describeExternalScenario(scenario, snapshot.name, maxEvidenceChars, snapshot.describeScenario)));
-			const selectionSet = Object.freeze(input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, snapshot.name, maxEvidenceChars, snapshot.describeScenario)));
-			const methodDir = `${input.runDir}/external/${safePathComponent(snapshot.name)}`;
-			const runId = externalOptimizerRunKey({
-				material: {
-					optimizer: {
-						kind: snapshot.source.kind,
-						package: snapshot.source.package,
-						version: snapshot.source.version,
-						...snapshot.source.sourceUrl ? { sourceUrl: snapshot.source.sourceUrl } : {},
-						...snapshot.source.revision ? { revision: snapshot.source.revision } : {}
-					},
-					method: snapshot.name,
-					evaluationId: snapshot.evaluationId,
-					dispatchRef: input.runOptions.dispatchRef ?? null,
-					objective: snapshot.objective,
-					background: snapshot.background ?? "",
-					seed: input.seed,
-					seedCandidate,
-					trainSet,
-					selectionSet,
-					maxEvaluations: snapshot.maxEvaluations,
-					maxOptimizerCostUsd: snapshot.maxOptimizerCostUsd,
-					maxCandidateChars,
-					maxEvidenceChars
-				},
-				attemptId,
-				resumeEnabled: resume !== "never"
-			});
-			const stateDir = `${methodDir}/state/${runId}`;
-			const artifactDir = `${methodDir}/attempts/${attemptId}`;
-			const manifestPath = `${stateDir}/run-manifest.jsonl`;
-			const evaluationCostPhase = "external.evaluation";
-			const optimizerCostPhase = "external.optimizer";
-			storage.ensureDir(stateDir);
-			storage.ensureDir(artifactDir);
-			if (resume !== "never") await mkdir(stateDir, { recursive: true });
-			const lock = resume === "never" ? void 0 : acquireSingleRunLock({
-				lockPath: `${stateDir}.lock`,
-				releaseOnExit: true
-			});
-			let releaseLock = true;
-			try {
-				let manifest = resume === "never" ? void 0 : readExternalOptimizerRunManifest(storage.read(manifestPath), storage.exists(manifestPath), manifestPath, runId);
-				const restoreRequested = manifest !== void 0;
-				if (resume === "required" && !restoreRequested) throw new Error(`${snapshot.name}: no compatible run state is available to resume`);
-				if (resume === "never" && restoreRequested) throw new Error(`${snapshot.name}: fresh optimizer run unexpectedly found prior state`);
-				if (resume !== "never") manifest = appendExternalOptimizerRunManifestEvent({
-					storage,
-					path: manifestPath,
-					revision: manifest?.revision ?? 0,
-					event: {
-						runId,
-						attemptId,
-						status: "partial"
-					}
-				});
-				const runBudget = openExternalOptimizerRunBudget({
-					storage,
-					runDir: methodDir,
-					runKey: runId,
-					attemptId,
-					maxEvaluations: snapshot.maxEvaluations
-				});
-				const optimizerLedger = createRunCostLedger({
-					storage,
-					runDir: `${stateDir}/cost`,
-					costCeilingUsd: snapshot.maxOptimizerCostUsd
-				});
-				const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, `${snapshot.name} optimizer`);
-				const score = createExternalTextEvaluator({
-					input,
-					label: `${snapshot.name} optimizer`,
-					runDir: artifactDir,
-					compatibleRunId: runId,
-					costPhase: evaluationCostPhase,
-					costTags: runBudget.attemptTags,
-					costLedger: input.costLedger,
-					scenarioById,
-					maxCandidateChars,
-					maxEvidenceChars,
-					describeArtifact: snapshot.describeArtifact
-				});
-				let acceptingEvaluations = true;
-				const activeEvaluations = /* @__PURE__ */ new Set();
-				const controller = new AbortController();
-				const optimizerCostMeter = { async runPaidCall(request) {
-					const call = {
-						methodResult: void 0,
-						providerStarted: false
-					};
-					const subLimitResult = await optimizerLedger.runPaidCall({
-						...request,
-						channel: request.channel ?? "optimizer",
-						phase: optimizerCostPhase,
-						tags: runBudget.attemptTags,
-						signal: request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal,
-						execute: async (signal, callId) => {
-							call.methodResult = await input.costLedger.runPaidCall({
-								...request,
-								callId,
-								channel: request.channel ?? "optimizer",
-								phase: optimizerCostPhase,
-								tags: runBudget.attemptTags,
-								signal,
-								execute: (methodSignal, methodCallId) => {
-									call.providerStarted = true;
-									return request.execute(methodSignal, methodCallId);
-								}
-							});
-							if (!call.methodResult.succeeded) throw new Error(`${snapshot.name}: method cost account rejected optimizer call`, { cause: call.methodResult.error });
-							return call.methodResult.value;
-						},
-						receipt: () => {
-							if (!call.methodResult?.succeeded) throw new Error(`${snapshot.name}: optimizer call completed without a receipt`);
-							return mirroredCostReceipt(call.methodResult.receipt);
-						},
-						receiptFromError: () => {
-							if (call.methodResult?.receipt) return mirroredCostReceipt(call.methodResult.receipt);
-							if (!call.providerStarted) return noChargeReceipt(modelBeforeExecution(request));
-						}
-					});
-					if (call.methodResult === void 0) return subLimitResult;
-					if (!call.methodResult.succeeded) return call.methodResult;
-					return subLimitResult.succeeded ? call.methodResult : subLimitResult;
-				} };
-				Object.freeze(optimizerCostMeter);
-				const evaluate = (request, signal = controller.signal) => {
-					if (!acceptingEvaluations) throw new Error(`${snapshot.name}: evaluate cannot be called after run() completes`);
-					if (runBudget.acceptEvaluation() === void 0) throw new Error(`${snapshot.name}: maxEvaluations limit reached`);
-					const combinedSignal = signal === controller.signal ? controller.signal : AbortSignal.any([controller.signal, signal]);
-					const pending = score(cloneExternalEvaluationRequest(request), combinedSignal);
-					activeEvaluations.add(pending);
-					const remove = () => activeEvaluations.delete(pending);
-					pending.then(remove, remove);
-					return pending;
-				};
-				const started = Date.now();
-				const timeoutMs = snapshot.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-				const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`${snapshot.name}: optimizer exceeded ${timeoutMs}ms`)), timeoutMs);
-				let result;
-				let runError;
-				let outstandingAtCompletion = 0;
-				let paidCallsAtCompletion = 0;
-				let runSettled = false;
-				const runPromise = Promise.resolve().then(() => snapshot.run(Object.freeze({
-					runId,
-					name: snapshot.name,
-					objective: snapshot.objective,
-					evaluationId: snapshot.evaluationId,
-					...snapshot.background ? { background: snapshot.background } : {},
-					seedCandidate: cloneExternalTextCandidate(seedCandidate),
-					trainSet,
-					selectionSet,
-					maxEvaluations: snapshot.maxEvaluations,
-					seed: input.seed,
-					stateDir,
-					restoreRequested,
-					artifactDir,
-					signal: controller.signal,
-					cost: optimizerCostMeter,
-					evaluate
-				})));
-				runPromise.then(() => {
-					runSettled = true;
-				}, () => {
-					runSettled = true;
-				});
-				try {
-					result = await raceWithAbort(runPromise, controller.signal);
-					outstandingAtCompletion = activeEvaluations.size;
-					paidCallsAtCompletion = optimizerLedger.summary().pendingCalls;
-				} catch (error) {
-					runError = error;
-				} finally {
-					acceptingEvaluations = false;
-					clearTimeout(timeout);
-				}
-				await Promise.allSettled([...activeEvaluations]);
-				const paidCallsSettled = await optimizerLedger.waitForIdle({ timeoutMs: 5e3 });
-				if (runError !== void 0) {
-					if ((!runSettled || !paidCallsSettled) && lock) {
-						releaseLock = false;
-						Promise.allSettled([runPromise, optimizerLedger.waitForIdle({ timeoutMs: MAX_TIMER_DELAY_MS$2 })]).then(() => lock.release());
-					}
-					throw runError;
-				}
-				if (!paidCallsSettled) {
-					if (lock) {
-						releaseLock = false;
-						Promise.allSettled([runPromise, optimizerLedger.waitForIdle({ timeoutMs: MAX_TIMER_DELAY_MS$2 })]).then(() => lock.release());
-					}
-					throw new Error(`${snapshot.name}: optimizer paid calls did not settle`);
-				}
-				if (paidCallsAtCompletion > 0) throw new Error(`${snapshot.name}: run() completed with ${paidCallsAtCompletion} outstanding paid call(s); await every context.cost.runPaidCall()`);
-				if (outstandingAtCompletion > 0) throw new Error(`${snapshot.name}: run() completed with ${outstandingAtCompletion} outstanding evaluation(s); await every evaluate() call`);
-				assertExternalTextOptimizerResult(result, snapshot.name, maxCandidateChars, expectsComponents);
-				if (result.resumed !== restoreRequested) throw new Error(`${snapshot.name}: optimizer reported resumed=${String(result.resumed)} but restoreRequested=${String(restoreRequested)}`);
-				const evaluationCost = costFromLedgerSummary(input.costLedger.summary({
-					phase: evaluationCostPhase,
-					tags: runBudget.runTags
-				}));
-				const optimizerFilter = {
-					phase: optimizerCostPhase,
-					tags: runBudget.runTags
-				};
-				const optimizerReceipts = input.costLedger.list(optimizerFilter);
-				const optimizerSummary = input.costLedger.summary(optimizerFilter);
-				const optimizerCost = costFromLedgerSummary(optimizerSummary);
-				assertExternalCostAccounting(result.costAccounting, optimizerSummary.totalCalls, snapshot.name);
-				const externalCostReason = result.costAccounting.kind === "external" ? result.costAccounting.reason : void 0;
-				const tokenUsage = optimizationTokenUsageFromSummary(optimizerSummary, optimizerReceipts);
-				if (resume !== "never") appendExternalOptimizerRunManifestEvent({
-					storage,
-					path: manifestPath,
-					revision: manifest.revision,
-					event: {
-						runId,
-						attemptId,
-						status: "completed"
+		optimize: (input) => optimizeExternalText(snapshot, input)
+	};
+}
+const EVALUATION_COST_PHASE = "external.evaluation";
+const OPTIMIZER_COST_PHASE = "external.optimizer";
+async function optimizeExternalText(snapshot, input) {
+	const run = await prepareExternalRun(snapshot, input);
+	try {
+		const { manifest, restoreRequested } = restoreRunManifest(run);
+		const accounts = openRunAccounts(run);
+		const session = startOptimizerSession(run, accounts, restoreRequested);
+		return finishRun(run, accounts, session, manifest, await awaitOptimizerResult(run, accounts, session, restoreRequested));
+	} finally {
+		if (run.releaseLock) run.lock?.release();
+	}
+}
+function describeExternalScenarios(scenarios, snapshot, maxEvidenceChars) {
+	return Object.freeze(scenarios.map((scenario) => describeExternalScenario(scenario, snapshot.name, maxEvidenceChars, snapshot.describeScenario)));
+}
+/** Run identity, scenario descriptions and directories, then the resume lock. */
+async function prepareExternalRun(snapshot, input) {
+	const seedCandidate = encodeExternalTextCandidate(input.baselineSurface);
+	const maxCandidateChars = snapshot.maxCandidateChars ?? DEFAULT_MAX_CANDIDATE_CHARS;
+	const maxEvidenceChars = snapshot.maxEvidenceChars ?? DEFAULT_MAX_EVIDENCE_CHARS;
+	const attemptId = randomBytes(16).toString("hex");
+	const storage = input.runOptions.storage ?? fsCampaignStorage();
+	const resume = snapshot.resume ?? "never";
+	const trainSet = describeExternalScenarios(input.trainScenarios, snapshot, maxEvidenceChars);
+	const selectionSet = describeExternalScenarios(input.selectionScenarios, snapshot, maxEvidenceChars);
+	const methodDir = `${input.runDir}/external/${safePathComponent(snapshot.name)}`;
+	const runId = externalOptimizerRunKey({
+		material: {
+			optimizer: {
+				kind: snapshot.source.kind,
+				package: snapshot.source.package,
+				version: snapshot.source.version,
+				...snapshot.source.sourceUrl ? { sourceUrl: snapshot.source.sourceUrl } : {},
+				...snapshot.source.revision ? { revision: snapshot.source.revision } : {}
+			},
+			method: snapshot.name,
+			evaluationId: snapshot.evaluationId,
+			dispatchRef: input.runOptions.dispatchRef ?? null,
+			objective: snapshot.objective,
+			background: snapshot.background ?? "",
+			seed: input.seed,
+			seedCandidate,
+			trainSet,
+			selectionSet,
+			maxEvaluations: snapshot.maxEvaluations,
+			maxOptimizerCostUsd: snapshot.maxOptimizerCostUsd,
+			maxCandidateChars,
+			maxEvidenceChars
+		},
+		attemptId,
+		resumeEnabled: resume !== "never"
+	});
+	const stateDir = `${methodDir}/state/${runId}`;
+	const artifactDir = `${methodDir}/attempts/${attemptId}`;
+	storage.ensureDir(stateDir);
+	storage.ensureDir(artifactDir);
+	if (resume !== "never") await mkdir(stateDir, { recursive: true });
+	const lock = resume === "never" ? void 0 : acquireSingleRunLock({
+		lockPath: `${stateDir}.lock`,
+		releaseOnExit: true
+	});
+	return {
+		snapshot,
+		input,
+		seedCandidate,
+		expectsComponents: typeof seedCandidate !== "string",
+		maxCandidateChars,
+		maxEvidenceChars,
+		attemptId,
+		storage,
+		resume,
+		trainSet,
+		selectionSet,
+		methodDir,
+		runId,
+		stateDir,
+		artifactDir,
+		manifestPath: `${stateDir}/run-manifest.jsonl`,
+		lock,
+		releaseLock: true
+	};
+}
+/** Reads prior state when resuming, and records this attempt as partial. */
+function restoreRunManifest(run) {
+	const { snapshot, storage, manifestPath, runId, attemptId, resume } = run;
+	let manifest = resume === "never" ? void 0 : readExternalOptimizerRunManifest(storage.read(manifestPath), storage.exists(manifestPath), manifestPath, runId);
+	const restoreRequested = manifest !== void 0;
+	if (resume === "required" && !restoreRequested) throw new Error(`${snapshot.name}: no compatible run state is available to resume`);
+	if (resume === "never" && restoreRequested) throw new Error(`${snapshot.name}: fresh optimizer run unexpectedly found prior state`);
+	if (resume !== "never") manifest = appendExternalOptimizerRunManifestEvent({
+		storage,
+		path: manifestPath,
+		revision: manifest?.revision ?? 0,
+		event: {
+			runId,
+			attemptId,
+			status: "partial"
+		}
+	});
+	return {
+		manifest,
+		restoreRequested
+	};
+}
+function openRunAccounts(run) {
+	const { snapshot, storage, methodDir, runId, attemptId, stateDir } = run;
+	return {
+		runBudget: openExternalOptimizerRunBudget({
+			storage,
+			runDir: methodDir,
+			runKey: runId,
+			attemptId,
+			maxEvaluations: snapshot.maxEvaluations
+		}),
+		optimizerLedger: createRunCostLedger({
+			storage,
+			runDir: `${stateDir}/cost`,
+			costCeilingUsd: snapshot.maxOptimizerCostUsd
+		})
+	};
+}
+/** Optimizer paid calls, charged to the optimizer's own limit and mirrored into the method's account. */
+function createOptimizerCostMeter(run, accounts, controller) {
+	const { snapshot, input } = run;
+	const { runBudget, optimizerLedger } = accounts;
+	return Object.freeze({ async runPaidCall(request) {
+		const call = {
+			methodResult: void 0,
+			providerStarted: false
+		};
+		const subLimitResult = await optimizerLedger.runPaidCall({
+			...request,
+			channel: request.channel ?? "optimizer",
+			phase: OPTIMIZER_COST_PHASE,
+			tags: runBudget.attemptTags,
+			signal: request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal,
+			execute: async (signal, callId) => {
+				call.methodResult = await input.costLedger.runPaidCall({
+					...request,
+					callId,
+					channel: request.channel ?? "optimizer",
+					phase: OPTIMIZER_COST_PHASE,
+					tags: runBudget.attemptTags,
+					signal,
+					execute: (methodSignal, methodCallId) => {
+						call.providerStarted = true;
+						return request.execute(methodSignal, methodCallId);
 					}
 				});
-				const measuredCost = combineComparisonCosts([{
-					label: "evaluation",
-					cost: evaluationCost
-				}, {
-					label: "optimizer",
-					cost: optimizerCost
-				}]);
-				return {
-					winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
-					cost: {
-						...measuredCost,
-						...externalCostReason ? { costProvenance: {
-							kind: "uncaptured",
-							usd: null
-						} } : {},
-						accountingComplete: measuredCost.accountingComplete && externalCostReason === void 0,
-						incompleteReasons: [...measuredCost.incompleteReasons, ...externalCostReason ? [`optimizer: external spend is not observed: ${externalCostReason}`] : []]
-					},
-					durationMs: Date.now() - started,
-					provenance: {
-						source: {
-							...snapshot.source,
-							evidence: "declared"
-						},
-						runId,
-						resumed: result.resumed,
-						evaluationCount: runBudget.acceptedEvaluations(),
-						artifactDir,
-						...tokenUsage ? { tokenUsage } : {}
-					}
-				};
-			} finally {
-				if (releaseLock) lock?.release();
+				if (!call.methodResult.succeeded) throw new Error(`${snapshot.name}: method cost account rejected optimizer call`, { cause: call.methodResult.error });
+				return call.methodResult.value;
+			},
+			receipt: () => {
+				if (!call.methodResult?.succeeded) throw new Error(`${snapshot.name}: optimizer call completed without a receipt`);
+				return mirroredCostReceipt(call.methodResult.receipt);
+			},
+			receiptFromError: () => {
+				if (call.methodResult?.receipt) return mirroredCostReceipt(call.methodResult.receipt);
+				if (!call.providerStarted) return noChargeReceipt(modelBeforeExecution(request));
 			}
+		});
+		if (call.methodResult === void 0) return subLimitResult;
+		if (!call.methodResult.succeeded) return call.methodResult;
+		return subLimitResult.succeeded ? call.methodResult : subLimitResult;
+	} });
+}
+/** Starts the optimizer with its evaluator, cost meter, timeout and frozen context. */
+function startOptimizerSession(run, accounts, restoreRequested) {
+	const { snapshot, input, runId, stateDir, artifactDir } = run;
+	const { runBudget } = accounts;
+	const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, `${snapshot.name} optimizer`);
+	const score = createExternalTextEvaluator({
+		input,
+		label: `${snapshot.name} optimizer`,
+		runDir: artifactDir,
+		compatibleRunId: runId,
+		costPhase: EVALUATION_COST_PHASE,
+		costTags: runBudget.attemptTags,
+		costLedger: input.costLedger,
+		scenarioById,
+		maxCandidateChars: run.maxCandidateChars,
+		maxEvidenceChars: run.maxEvidenceChars,
+		describeArtifact: snapshot.describeArtifact
+	});
+	const controller = new AbortController();
+	const activeEvaluations = /* @__PURE__ */ new Set();
+	const state = {
+		acceptingEvaluations: true,
+		runSettled: false
+	};
+	const optimizerCostMeter = createOptimizerCostMeter(run, accounts, controller);
+	const evaluate = (request, signal = controller.signal) => {
+		if (!state.acceptingEvaluations) throw new Error(`${snapshot.name}: evaluate cannot be called after run() completes`);
+		if (runBudget.acceptEvaluation() === void 0) throw new Error(`${snapshot.name}: maxEvaluations limit reached`);
+		const combinedSignal = signal === controller.signal ? controller.signal : AbortSignal.any([controller.signal, signal]);
+		const pending = score(cloneExternalEvaluationRequest(request), combinedSignal);
+		activeEvaluations.add(pending);
+		const remove = () => activeEvaluations.delete(pending);
+		pending.then(remove, remove);
+		return pending;
+	};
+	const started = Date.now();
+	const timeoutMs = snapshot.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`${snapshot.name}: optimizer exceeded ${timeoutMs}ms`)), timeoutMs);
+	const runPromise = Promise.resolve().then(() => snapshot.run(Object.freeze({
+		runId,
+		name: snapshot.name,
+		objective: snapshot.objective,
+		evaluationId: snapshot.evaluationId,
+		...snapshot.background ? { background: snapshot.background } : {},
+		seedCandidate: cloneExternalTextCandidate(run.seedCandidate),
+		trainSet: run.trainSet,
+		selectionSet: run.selectionSet,
+		maxEvaluations: snapshot.maxEvaluations,
+		seed: input.seed,
+		stateDir,
+		restoreRequested,
+		artifactDir,
+		signal: controller.signal,
+		cost: optimizerCostMeter,
+		evaluate
+	})));
+	const markSettled = () => {
+		state.runSettled = true;
+	};
+	runPromise.then(markSettled, markSettled);
+	return {
+		controller,
+		activeEvaluations,
+		runPromise,
+		timeout,
+		started,
+		state
+	};
+}
+/** Waits for the optimizer, then refuses a run that left evaluations or paid calls outstanding. */
+async function awaitOptimizerResult(run, accounts, session, restoreRequested) {
+	const { snapshot, lock } = run;
+	const { optimizerLedger } = accounts;
+	let result;
+	let runError;
+	let outstandingAtCompletion = 0;
+	let paidCallsAtCompletion = 0;
+	try {
+		result = await raceWithAbort(session.runPromise, session.controller.signal);
+		outstandingAtCompletion = session.activeEvaluations.size;
+		paidCallsAtCompletion = optimizerLedger.summary().pendingCalls;
+	} catch (error) {
+		runError = error;
+	} finally {
+		session.state.acceptingEvaluations = false;
+		clearTimeout(session.timeout);
+	}
+	await Promise.allSettled([...session.activeEvaluations]);
+	const paidCallsSettled = await optimizerLedger.waitForIdle({ timeoutMs: 5e3 });
+	const handOffLock = () => {
+		if (!lock) return;
+		run.releaseLock = false;
+		Promise.allSettled([session.runPromise, optimizerLedger.waitForIdle({ timeoutMs: MAX_TIMER_DELAY_MS$2 })]).then(() => lock.release());
+	};
+	if (runError !== void 0) {
+		if (!session.state.runSettled || !paidCallsSettled) handOffLock();
+		throw runError;
+	}
+	if (!paidCallsSettled) {
+		handOffLock();
+		throw new Error(`${snapshot.name}: optimizer paid calls did not settle`);
+	}
+	if (paidCallsAtCompletion > 0) throw new Error(`${snapshot.name}: run() completed with ${paidCallsAtCompletion} outstanding paid call(s); await every context.cost.runPaidCall()`);
+	if (outstandingAtCompletion > 0) throw new Error(`${snapshot.name}: run() completed with ${outstandingAtCompletion} outstanding evaluation(s); await every evaluate() call`);
+	assertExternalTextOptimizerResult(result, snapshot.name, run.maxCandidateChars, run.expectsComponents);
+	if (result.resumed !== restoreRequested) throw new Error(`${snapshot.name}: optimizer reported resumed=${String(result.resumed)} but restoreRequested=${String(restoreRequested)}`);
+	return result;
+}
+/** Measures evaluation and optimizer spend, records completion, and builds the method result. */
+function finishRun(run, accounts, session, manifest, result) {
+	const { snapshot, input, storage, runId, attemptId } = run;
+	const { runBudget } = accounts;
+	const evaluationCost = costFromLedgerSummary(input.costLedger.summary({
+		phase: EVALUATION_COST_PHASE,
+		tags: runBudget.runTags
+	}));
+	const optimizerFilter = {
+		phase: OPTIMIZER_COST_PHASE,
+		tags: runBudget.runTags
+	};
+	const optimizerReceipts = input.costLedger.list(optimizerFilter);
+	const optimizerSummary = input.costLedger.summary(optimizerFilter);
+	const optimizerCost = costFromLedgerSummary(optimizerSummary);
+	assertExternalCostAccounting(result.costAccounting, optimizerSummary.totalCalls, snapshot.name);
+	const externalCostReason = result.costAccounting.kind === "external" ? result.costAccounting.reason : void 0;
+	const tokenUsage = optimizationTokenUsageFromSummary(optimizerSummary, optimizerReceipts);
+	if (run.resume !== "never") appendExternalOptimizerRunManifestEvent({
+		storage,
+		path: run.manifestPath,
+		revision: manifest.revision,
+		event: {
+			runId,
+			attemptId,
+			status: "completed"
+		}
+	});
+	const measuredCost = combineComparisonCosts([{
+		label: "evaluation",
+		cost: evaluationCost
+	}, {
+		label: "optimizer",
+		cost: optimizerCost
+	}]);
+	return {
+		winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
+		cost: {
+			...measuredCost,
+			...externalCostReason ? { costProvenance: {
+				kind: "uncaptured",
+				usd: null
+			} } : {},
+			accountingComplete: measuredCost.accountingComplete && externalCostReason === void 0,
+			incompleteReasons: [...measuredCost.incompleteReasons, ...externalCostReason ? [`optimizer: external spend is not observed: ${externalCostReason}`] : []]
+		},
+		durationMs: Date.now() - session.started,
+		provenance: {
+			source: {
+				...snapshot.source,
+				evidence: "declared"
+			},
+			runId,
+			resumed: result.resumed,
+			evaluationCount: runBudget.acceptedEvaluations(),
+			artifactDir: run.artifactDir,
+			...tokenUsage ? { tokenUsage } : {}
 		}
 	};
 }
@@ -1000,30 +1071,6 @@ function heldOutGate(options) {
 	};
 }
 //#endregion
-//#region src/campaign/external-optimizer-accounting.ts
-const TOKEN_USAGE_FIELDS = [
-	"inputTokens",
-	"outputTokens",
-	"totalTokens",
-	"calls"
-];
-function assertPriorExternalOptimizerUsage(summary, budget, name) {
-	if (!summary.usageComplete || budget.maxCostUsd !== void 0 && !summary.accountingComplete) throw new Error(`${name}: cannot resume optimizer-model work with incomplete bounded usage`);
-	if (summary.totalCalls > budget.maxRequests || budget.maxCostUsd !== void 0 && summary.totalCostUsd > budget.maxCostUsd + Number.EPSILON) throw new Error(`${name}: prior optimizer-model usage exceeds the configured budget`);
-}
-function assertExternalOptimizerTokenUsage(usage, name, optimizer) {
-	if (usage === void 0) return;
-	for (const field of TOKEN_USAGE_FIELDS) if (!Number.isSafeInteger(usage[field]) || usage[field] < 0) throw new Error(`${name}: ${optimizer} bridge returned invalid tokenUsage.${field}`);
-	if (usage.totalTokens !== usage.inputTokens + usage.outputTokens) throw new Error(`${name}: ${optimizer} bridge returned inconsistent tokenUsage.totalTokens`);
-	if (usage.requestAttempts !== void 0 && (!Number.isSafeInteger(usage.requestAttempts) || usage.requestAttempts < usage.calls)) throw new Error(`${name}: ${optimizer} bridge returned invalid tokenUsage.requestAttempts`);
-}
-function assertExternalOptimizerCompletionCount(upstream, requestAttempts, successfulCompletions, name, optimizer) {
-	if (!upstream) throw new Error(`${name}: ${optimizer} did not report optimizer token usage`);
-	if (!Number.isSafeInteger(requestAttempts) || !Number.isSafeInteger(successfulCompletions) || requestAttempts < 0 || successfulCompletions < 0 || successfulCompletions > requestAttempts) throw new Error(`${name}: optimizer model proxy returned invalid request counts`);
-	if (upstream.calls !== successfulCompletions) throw new Error(`${name}: ${optimizer} reported ${upstream.calls} successful model calls but the proxy completed ${successfulCompletions} across ${requestAttempts} attempts`);
-	if (upstream.requestAttempts !== void 0 && upstream.requestAttempts !== requestAttempts) throw new Error(`${name}: ${optimizer} reported ${upstream.requestAttempts} model attempts but the proxy received ${requestAttempts}`);
-}
-//#endregion
 //#region src/campaign/external-optimizer-run-config.ts
 function externalOptimizerRunnerIdentity(runner, module) {
 	return {
@@ -1048,72 +1095,6 @@ function snapshotJson(value, label) {
 	return JSON.parse(serialized);
 }
 //#endregion
-//#region src/campaign/external-optimizer-source.ts
-function assertExternalOptimizerPackageSource(value, expectedPackage, name, optimizer) {
-	assertExternalOptimizerPackageIdentity(value, expectedPackage, name, optimizer);
-	assertExternalOptimizerSourceDetails(value, name, optimizer);
-}
-function assertExternalOptimizerPackageIdentity(value, expectedPackage, name, optimizer) {
-	if (!isRecord(value) || value.package !== expectedPackage || typeof value.version !== "string" || value.version.length === 0 || value.version !== value.version.trim()) throw new Error(`${name}: ${optimizer} bridge returned invalid upstream package provenance`);
-}
-function assertExternalOptimizerSourceDetails(value, name, optimizer) {
-	if (value.sourceUrl !== void 0 && (typeof value.sourceUrl !== "string" || value.sourceUrl.length === 0 || value.sourceUrl !== value.sourceUrl.trim())) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream sourceUrl`);
-	if (value.revision !== void 0 && (typeof value.revision !== "string" || value.revision.length === 0 || value.revision !== value.revision.trim())) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream revision`);
-	if (value.sourceSha256 !== void 0 && (typeof value.sourceSha256 !== "string" || !/^[0-9a-f]{64}$/.test(value.sourceSha256))) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream sourceSha256`);
-}
-function observedExternalOptimizerPackageSource(value) {
-	return {
-		kind: "package",
-		evidence: "observed",
-		package: value.package,
-		version: value.version,
-		...value.sourceUrl ? { sourceUrl: value.sourceUrl } : {},
-		...value.revision ? { revision: value.revision } : {},
-		...value.sourceSha256 ? { sourceSha256: value.sourceSha256 } : {}
-	};
-}
-//#endregion
-//#region src/campaign/external-optimizer-runtime.ts
-async function inspectExternalOptimizerRuntime(args) {
-	const result = await runExternalOptimizerProcess({
-		label: `${args.label} source inspection`,
-		tempPrefix: `agent-eval-${args.package}-inspect-`,
-		module: args.module,
-		input: {
-			operation: "inspect",
-			engineModules: [...args.engineModules ?? []]
-		},
-		...args.runner ? { runner: args.runner } : {},
-		timeoutMs: args.timeoutMs,
-		...args.signal ? { signal: args.signal } : {}
-	});
-	assertExternalOptimizerRuntimeIdentity(result.runtime, args.package, args.label);
-	return result.runtime;
-}
-function observedExternalOptimizerRuntime(runtime) {
-	return {
-		source: observedExternalOptimizerPackageSource(runtime.optimizer),
-		bridge: observedExternalOptimizerPackageSource(runtime.bridge),
-		modules: runtime.engineModules.map((module) => ({ ...module })),
-		python: { ...runtime.python }
-	};
-}
-function assertExternalOptimizerRunBinding(args) {
-	if (!isDeepStrictEqual(args.returnedSource, args.runtime.optimizer)) throw new Error(`${args.label}: optimizer package changed after source inspection`);
-	if (args.returnedRunId !== args.runId) throw new Error(`${args.label}: bridge returned a different run ID`);
-	if (args.resume === "never" && args.resumed) throw new Error(`${args.label}: fresh run reported restored state`);
-	if (args.resume === "required" && !args.resumed) throw new Error(`${args.label}: required resume did not restore state`);
-	if (!args.runId.startsWith(args.compatibleRunId)) throw new Error(`${args.label}: run ID is not bound to its compatible identity`);
-}
-function assertExternalOptimizerRuntimeIdentity(value, expectedPackage, label) {
-	if (!isRecord(value)) throw new Error(`${label}: source inspection returned no runtime identity`);
-	assertExternalOptimizerPackageSource(value.bridge, "agent-eval-rpc", label, "bridge");
-	assertExternalOptimizerPackageSource(value.optimizer, expectedPackage, label, expectedPackage);
-	if (!value.bridge.sourceSha256 || !value.optimizer.sourceSha256) throw new Error(`${label}: source inspection omitted package source hashes`);
-	if (!isRecord(value.python) || typeof value.python.implementation !== "string" || value.python.implementation.length === 0 || value.python.implementation !== value.python.implementation.trim() || typeof value.python.version !== "string" || value.python.version.length === 0 || value.python.version !== value.python.version.trim()) throw new Error(`${label}: source inspection returned an invalid Python runtime`);
-	if (!Array.isArray(value.engineModules) || value.engineModules.some((module) => !isRecord(module) || typeof module.module !== "string" || module.module.length === 0 || module.module !== module.module.trim() || typeof module.sourceSha256 !== "string" || !/^[0-9a-f]{64}$/.test(module.sourceSha256))) throw new Error(`${label}: source inspection returned invalid engine modules`);
-}
-//#endregion
 //#region src/campaign/optimizer-model.ts
 function assertOptimizerModel(value, label) {
 	if (!value || typeof value !== "object") throw new Error(`${label} is required`);
@@ -1311,6 +1292,96 @@ function addEvaluationLimit(total, increment) {
 	return next;
 }
 //#endregion
+//#region src/campaign/external-optimizer-accounting.ts
+const TOKEN_USAGE_FIELDS = [
+	"inputTokens",
+	"outputTokens",
+	"totalTokens",
+	"calls"
+];
+function assertPriorExternalOptimizerUsage(summary, budget, name) {
+	if (!summary.usageComplete || budget.maxCostUsd !== void 0 && !summary.accountingComplete) throw new Error(`${name}: cannot resume optimizer-model work with incomplete bounded usage`);
+	if (summary.totalCalls > budget.maxRequests || budget.maxCostUsd !== void 0 && summary.totalCostUsd > budget.maxCostUsd + Number.EPSILON) throw new Error(`${name}: prior optimizer-model usage exceeds the configured budget`);
+}
+function assertExternalOptimizerTokenUsage(usage, name, optimizer) {
+	if (usage === void 0) return;
+	for (const field of TOKEN_USAGE_FIELDS) if (!Number.isSafeInteger(usage[field]) || usage[field] < 0) throw new Error(`${name}: ${optimizer} bridge returned invalid tokenUsage.${field}`);
+	if (usage.totalTokens !== usage.inputTokens + usage.outputTokens) throw new Error(`${name}: ${optimizer} bridge returned inconsistent tokenUsage.totalTokens`);
+	if (usage.requestAttempts !== void 0 && (!Number.isSafeInteger(usage.requestAttempts) || usage.requestAttempts < usage.calls)) throw new Error(`${name}: ${optimizer} bridge returned invalid tokenUsage.requestAttempts`);
+}
+function assertExternalOptimizerCompletionCount(upstream, requestAttempts, successfulCompletions, name, optimizer) {
+	if (!upstream) throw new Error(`${name}: ${optimizer} did not report optimizer token usage`);
+	if (!Number.isSafeInteger(requestAttempts) || !Number.isSafeInteger(successfulCompletions) || requestAttempts < 0 || successfulCompletions < 0 || successfulCompletions > requestAttempts) throw new Error(`${name}: optimizer model proxy returned invalid request counts`);
+	if (upstream.calls !== successfulCompletions) throw new Error(`${name}: ${optimizer} reported ${upstream.calls} successful model calls but the proxy completed ${successfulCompletions} across ${requestAttempts} attempts`);
+	if (upstream.requestAttempts !== void 0 && upstream.requestAttempts !== requestAttempts) throw new Error(`${name}: ${optimizer} reported ${upstream.requestAttempts} model attempts but the proxy received ${requestAttempts}`);
+}
+//#endregion
+//#region src/campaign/external-optimizer-source.ts
+function assertExternalOptimizerPackageSource(value, expectedPackage, name, optimizer) {
+	assertExternalOptimizerPackageIdentity(value, expectedPackage, name, optimizer);
+	assertExternalOptimizerSourceDetails(value, name, optimizer);
+}
+function assertExternalOptimizerPackageIdentity(value, expectedPackage, name, optimizer) {
+	if (!isRecord(value) || value.package !== expectedPackage || typeof value.version !== "string" || value.version.length === 0 || value.version !== value.version.trim()) throw new Error(`${name}: ${optimizer} bridge returned invalid upstream package provenance`);
+}
+function assertExternalOptimizerSourceDetails(value, name, optimizer) {
+	if (value.sourceUrl !== void 0 && (typeof value.sourceUrl !== "string" || value.sourceUrl.length === 0 || value.sourceUrl !== value.sourceUrl.trim())) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream sourceUrl`);
+	if (value.revision !== void 0 && (typeof value.revision !== "string" || value.revision.length === 0 || value.revision !== value.revision.trim())) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream revision`);
+	if (value.sourceSha256 !== void 0 && (typeof value.sourceSha256 !== "string" || !/^[0-9a-f]{64}$/.test(value.sourceSha256))) throw new Error(`${name}: ${optimizer} bridge returned an invalid upstream sourceSha256`);
+}
+function observedExternalOptimizerPackageSource(value) {
+	return {
+		kind: "package",
+		evidence: "observed",
+		package: value.package,
+		version: value.version,
+		...value.sourceUrl ? { sourceUrl: value.sourceUrl } : {},
+		...value.revision ? { revision: value.revision } : {},
+		...value.sourceSha256 ? { sourceSha256: value.sourceSha256 } : {}
+	};
+}
+//#endregion
+//#region src/campaign/external-optimizer-runtime.ts
+async function inspectExternalOptimizerRuntime(args) {
+	const result = await runExternalOptimizerProcess({
+		label: `${args.label} source inspection`,
+		tempPrefix: `agent-eval-${args.package}-inspect-`,
+		module: args.module,
+		input: {
+			operation: "inspect",
+			engineModules: [...args.engineModules ?? []]
+		},
+		...args.runner ? { runner: args.runner } : {},
+		timeoutMs: args.timeoutMs,
+		...args.signal ? { signal: args.signal } : {}
+	});
+	assertExternalOptimizerRuntimeIdentity(result.runtime, args.package, args.label);
+	return result.runtime;
+}
+function observedExternalOptimizerRuntime(runtime) {
+	return {
+		source: observedExternalOptimizerPackageSource(runtime.optimizer),
+		bridge: observedExternalOptimizerPackageSource(runtime.bridge),
+		modules: runtime.engineModules.map((module) => ({ ...module })),
+		python: { ...runtime.python }
+	};
+}
+function assertExternalOptimizerRunBinding(args) {
+	if (!isDeepStrictEqual(args.returnedSource, args.runtime.optimizer)) throw new Error(`${args.label}: optimizer package changed after source inspection`);
+	if (args.returnedRunId !== args.runId) throw new Error(`${args.label}: bridge returned a different run ID`);
+	if (args.resume === "never" && args.resumed) throw new Error(`${args.label}: fresh run reported restored state`);
+	if (args.resume === "required" && !args.resumed) throw new Error(`${args.label}: required resume did not restore state`);
+	if (!args.runId.startsWith(args.compatibleRunId)) throw new Error(`${args.label}: run ID is not bound to its compatible identity`);
+}
+function assertExternalOptimizerRuntimeIdentity(value, expectedPackage, label) {
+	if (!isRecord(value)) throw new Error(`${label}: source inspection returned no runtime identity`);
+	assertExternalOptimizerPackageSource(value.bridge, "agent-eval-rpc", label, "bridge");
+	assertExternalOptimizerPackageSource(value.optimizer, expectedPackage, label, expectedPackage);
+	if (!value.bridge.sourceSha256 || !value.optimizer.sourceSha256) throw new Error(`${label}: source inspection omitted package source hashes`);
+	if (!isRecord(value.python) || typeof value.python.implementation !== "string" || value.python.implementation.length === 0 || value.python.implementation !== value.python.implementation.trim() || typeof value.python.version !== "string" || value.python.version.length === 0 || value.python.version !== value.python.version.trim()) throw new Error(`${label}: source inspection returned an invalid Python runtime`);
+	if (!Array.isArray(value.engineModules) || value.engineModules.some((module) => !isRecord(module) || typeof module.module !== "string" || module.module.length === 0 || module.module !== module.module.trim() || typeof module.sourceSha256 !== "string" || !/^[0-9a-f]{64}$/.test(module.sourceSha256))) throw new Error(`${label}: source inspection returned invalid engine modules`);
+}
+//#endregion
 //#region src/campaign/gepa-optimization-result.ts
 function assertGepaBridgeOutput(result, name, maxCandidateChars, recipeKind, maxEvaluations, maxPopulationCandidates, scenarioIds, expectsComponents, requiresCandidatePopulation) {
 	if (result.recipeKind !== recipeKind) throw new Error(`${name}: GEPA bridge reported recipe '${String(result.recipeKind)}'`);
@@ -1733,24 +1804,7 @@ async function recordExternalSearch(input) {
 	});
 }
 //#endregion
-//#region src/campaign/gepa-optimization-method.ts
-/**
-* Turn an optional GEPA installation into an `OptimizationMethod`.
-*
-* GEPA receives only serialized train and selection cases. The caller's final
-* test partition stays inside `compareOptimizationMethods`, which invokes this
-* method without a test-set field. The local callback routes every candidate
-* evaluation through the same dispatch and judges used by other methods.
-*/
-/**
-* Environment for a bridge child that spawns `claude` CLI subprocesses.
-*
-* Both agent CLI engines start the CLI with the bridge's own environment, so
-* these variables travel bridge → engine → CLI. They merge AFTER
-* `removeCredentialEnvironment`: the ephemeral loopback token is the only
-* credential the child may see, and a caller-supplied ANTHROPIC_AUTH_TOKEN is
-* stripped like any other credential.
-*/
+//#region src/campaign/gepa-optimization-run.ts
 function anthropicShimEnvironment(proxy, optimizer) {
 	return {
 		ANTHROPIC_BASE_URL: new URL(proxy.baseUrl).origin,
@@ -1763,370 +1817,501 @@ function anthropicShimEnvironment(proxy, optimizer) {
 		API_TIMEOUT_MS: String((optimizer.budget.requestTimeoutMs ?? 3e5) + 6e4)
 	};
 }
-function gepaOptimizationMethod(config) {
-	assertGepaOptimizationConfig(config);
-	config = snapshotGepaOptimizationConfig(config);
-	const name = config.name ?? defaultGepaMethodName(config.recipe);
+/** Spend the optimizer booked to its own candidate generation. Unknown stays
+*  unknown: the bridge reports proposer cost only when the engine measured it. */
+function optimizerAccounting(tokenUsage, proposerCostUsd) {
+	return {
+		tokens: tokenUsage?.inputTokens === void 0 || tokenUsage.outputTokens === void 0 ? {
+			status: "unknown",
+			reason: "the optimizer bridge reported no token usage"
+		} : {
+			status: "known",
+			inputTokens: tokenUsage.inputTokens,
+			outputTokens: tokenUsage.outputTokens,
+			cachedTokens: 0
+		},
+		cost: proposerCostUsd === void 0 ? {
+			status: "unknown",
+			knownLowerBoundUsd: 0,
+			reason: "the optimizer bridge reported no proposer cost"
+		} : {
+			status: "known",
+			usd: proposerCostUsd,
+			source: "provider"
+		}
+	};
+}
+/** The settled inputs of one GEPA run: its identity, budgets, evaluation callback and logs. */
+async function prepareGepaRun(config, input, name) {
+	const signal = input.runOptions.signal;
+	signal?.throwIfAborted();
+	if (typeof input.baselineSurface !== "string" && input.baselineSurface.kind !== "components") throw new Error(`${name}: GEPA bridge supports text and component surfaces`);
+	const expectsComponents = typeof input.baselineSurface !== "string";
+	if (expectsComponents) assertGepaComponentRecipe(config.recipe, name);
+	const started = Date.now();
+	const maxCandidateChars = config.maxCandidateChars ?? 2e5;
+	const maxEvidenceChars = config.maxEvidenceChars ?? 1e5;
+	const timeoutMs = config.timeoutMs ?? 18e5;
+	const storage = input.runOptions.storage ?? fsCampaignStorage();
+	const runDir = `${input.runDir}/gepa`;
+	storage.ensureDir(runDir);
+	const costLedger = input.costLedger;
+	const attemptId = randomBytes(16).toString("hex");
+	const resume = config.resume ?? "never";
+	const bridgeRunner = config.optimizer && config.runner ? {
+		...config.runner,
+		env: removeCredentialEnvironment(config.runner.env ?? {})
+	} : config.runner;
+	const runtimeIdentity = await inspectExternalOptimizerRuntime({
+		label: name,
+		package: "gepa",
+		module: "agent_eval_rpc.gepa_bridge",
+		engineModules: config.engineModules,
+		...bridgeRunner ? { runner: bridgeRunner } : {},
+		timeoutMs,
+		...signal ? { signal } : {}
+	});
+	const seedCandidate = encodeExternalTextCandidate(input.baselineSurface);
+	const trainSet = input.trainScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
+	const selectionSet = input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
+	const evaluationLimit = gepaRecipeEvaluationLimit(config.recipe, input.selectionScenarios.length);
+	const maxPopulationCandidates = Math.min(Number.MAX_SAFE_INTEGER, evaluationLimit + 1);
+	const populationScenarioIds = (selectionSet.length > 0 ? selectionSet : trainSet).map((scenario) => scenario.id);
+	const runMaterial = {
+		optimizer: "gepa",
+		runtime: runtimeIdentity,
+		method: name,
+		evaluationId: config.evaluationId,
+		dispatchRef: input.runOptions.dispatchRef ?? null,
+		seed: input.seed,
+		recipe: snapshotJson(config.recipe, "GEPA run settings"),
+		engineModules: config.engineModules ?? [],
+		objective: config.objective,
+		background: config.background ?? "",
+		seedCandidate,
+		trainSet,
+		selectionSet,
+		maxCandidateChars,
+		maxPopulationCandidates,
+		maxEvidenceChars,
+		evaluationCallbackLimits: resolveExternalOptimizerCallbackLimits(config.evaluationCallbackLimits),
+		optimizerModel: config.optimizer ? {
+			model: config.optimizer.model,
+			callRef: config.optimizer.callRef,
+			budget: config.optimizer.budget,
+			...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {}
+		} : null,
+		runner: externalOptimizerRunnerIdentity(bridgeRunner, "agent_eval_rpc.gepa_bridge"),
+		trustResumeState: config.trustResumeState === true
+	};
+	const compatibleRunId = externalOptimizerCompatibleRunKey(runMaterial);
+	const runId = externalOptimizerRunKey({
+		material: runMaterial,
+		attemptId,
+		resumeEnabled: resume !== "never" && gepaRecipeSupportsResume(config.recipe)
+	});
+	const runBudget = openExternalOptimizerRunBudget({
+		storage,
+		runDir,
+		runKey: runId,
+		attemptId,
+		maxEvaluations: evaluationLimit
+	});
+	const observationLog = openExternalOptimizerObservationLog({
+		storage,
+		path: `${runDir}/observations-${attemptId}.jsonl`
+	});
+	const executionLog = config.optimizer ? openExternalOptimizerExecutionLog({
+		storage,
+		path: `${runDir}/model-executions-${attemptId}.jsonl`
+	}) : void 0;
+	const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "GEPA bridge");
+	const evaluate = createExternalTextEvaluator({
+		input,
+		label: "GEPA bridge",
+		runDir,
+		compatibleRunId: runId,
+		costPhase: "gepa.external-evaluation",
+		costTags: runBudget.attemptTags,
+		costLedger,
+		scenarioById,
+		maxCandidateChars,
+		maxEvidenceChars,
+		describeArtifact: config.describeArtifact
+	});
+	let attemptEvaluationCount = 0;
 	return {
+		signal,
+		expectsComponents,
+		started,
+		maxCandidateChars,
+		maxEvidenceChars,
+		timeoutMs,
+		storage,
+		runDir,
+		costLedger,
+		attemptId,
+		resume,
+		bridgeRunner,
+		runtimeIdentity,
+		seedCandidate,
+		trainSet,
+		selectionSet,
+		evaluationLimit,
+		maxPopulationCandidates,
+		populationScenarioIds,
+		compatibleRunId,
+		runId,
+		runBudget,
+		observationLog,
+		executionLog,
+		callback: await startExternalOptimizerCallback({
+			token: randomBytes(32).toString("hex"),
+			maxEvaluations: evaluationLimit,
+			acceptEvaluation: () => {
+				if (runBudget.acceptEvaluation() === void 0) return void 0;
+				attemptEvaluationCount += 1;
+				return attemptEvaluationCount;
+			},
+			evaluate,
+			observe: observationLog.observe,
+			...config.evaluationCallbackLimits ? { limits: config.evaluationCallbackLimits } : {},
+			...signal ? { signal } : {}
+		}),
 		name,
-		async optimize(input) {
-			const signal = input.runOptions.signal;
-			signal?.throwIfAborted();
-			if (typeof input.baselineSurface !== "string" && input.baselineSurface.kind !== "components") throw new Error(`${name}: GEPA bridge supports text and component surfaces`);
-			const expectsComponents = typeof input.baselineSurface !== "string";
-			if (expectsComponents) assertGepaComponentRecipe(config.recipe, name);
-			const started = Date.now();
-			const maxCandidateChars = config.maxCandidateChars ?? 2e5;
-			const maxEvidenceChars = config.maxEvidenceChars ?? 1e5;
-			const timeoutMs = config.timeoutMs ?? 18e5;
-			const storage = input.runOptions.storage ?? fsCampaignStorage();
-			const runDir = `${input.runDir}/gepa`;
-			storage.ensureDir(runDir);
-			const costLedger = input.costLedger;
-			const attemptId = randomBytes(16).toString("hex");
-			const resume = config.resume ?? "never";
-			const bridgeRunner = config.optimizer && config.runner ? {
-				...config.runner,
-				env: removeCredentialEnvironment(config.runner.env ?? {})
-			} : config.runner;
-			const runtimeIdentity = await inspectExternalOptimizerRuntime({
-				label: name,
-				package: "gepa",
-				module: "agent_eval_rpc.gepa_bridge",
-				engineModules: config.engineModules,
-				...bridgeRunner ? { runner: bridgeRunner } : {},
-				timeoutMs,
-				...signal ? { signal } : {}
-			});
-			const seedCandidate = encodeExternalTextCandidate(input.baselineSurface);
-			const trainSet = input.trainScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
-			const selectionSet = input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, "GEPA", maxEvidenceChars, config.describeScenario));
-			const evaluationLimit = gepaRecipeEvaluationLimit(config.recipe, input.selectionScenarios.length);
-			const maxPopulationCandidates = Math.min(Number.MAX_SAFE_INTEGER, evaluationLimit + 1);
-			const populationScenarioIds = (selectionSet.length > 0 ? selectionSet : trainSet).map((scenario) => scenario.id);
-			const runMaterial = {
-				optimizer: "gepa",
-				runtime: runtimeIdentity,
-				method: name,
-				evaluationId: config.evaluationId,
-				dispatchRef: input.runOptions.dispatchRef ?? null,
-				seed: input.seed,
-				recipe: snapshotJson(config.recipe, "GEPA run settings"),
-				engineModules: config.engineModules ?? [],
-				objective: config.objective,
-				background: config.background ?? "",
-				seedCandidate,
-				trainSet,
-				selectionSet,
-				maxCandidateChars,
-				maxPopulationCandidates,
-				maxEvidenceChars,
-				evaluationCallbackLimits: resolveExternalOptimizerCallbackLimits(config.evaluationCallbackLimits),
-				optimizerModel: config.optimizer ? {
-					model: config.optimizer.model,
+		config,
+		input
+	};
+}
+/** Start the optimizer model proxy when one is configured, run the GEPA bridge, and release the resources either way. */
+async function runBridge(ctx) {
+	const { signal, maxCandidateChars, maxEvidenceChars, timeoutMs, runDir, costLedger, attemptId, resume, bridgeRunner, runtimeIdentity, seedCandidate, trainSet, selectionSet, maxPopulationCandidates, compatibleRunId, runId, runBudget, executionLog, callback, name, config, input } = ctx;
+	const runnerEnv = bridgeRunner?.env ?? {};
+	let modelProxy;
+	const bridgeRunnerForSpawn = () => {
+		if (!modelProxy) return bridgeRunner;
+		const anthropicChildEnv = config.optimizer?.anthropicEndpoint === true && gepaRecipeHasAgentCliEngine(config.recipe) ? anthropicShimEnvironment(modelProxy, config.optimizer) : void 0;
+		if (!bridgeRunner && !anthropicChildEnv) return bridgeRunner;
+		return {
+			...bridgeRunner ?? {},
+			env: {
+				...removeCredentialEnvironment(runnerEnv),
+				...anthropicChildEnv ?? {}
+			}
+		};
+	};
+	const closeResources = () => closeExternalOptimizerResources({
+		label: name,
+		callback,
+		...modelProxy ? { modelProxy } : {}
+	});
+	const { result, outputDir } = await runWithCleanup({
+		label: `${name} optimizer resources`,
+		run: async () => {
+			if (config.optimizer) {
+				const priorOptimizerUsage = costLedger.summary({
+					phase: "gepa.optimizer-model",
+					tags: runBudget.runTags
+				});
+				assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
+				modelProxy = await startExternalOptimizerModelProxy({
+					call: config.optimizer.call,
 					callRef: config.optimizer.callRef,
+					recordExecution: executionLog.observe,
+					model: config.optimizer.model,
 					budget: config.optimizer.budget,
-					...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {}
-				} : null,
-				runner: externalOptimizerRunnerIdentity(bridgeRunner, "agent_eval_rpc.gepa_bridge"),
-				trustResumeState: config.trustResumeState === true
-			};
-			const compatibleRunId = externalOptimizerCompatibleRunKey(runMaterial);
-			const runId = externalOptimizerRunKey({
-				material: runMaterial,
-				attemptId,
-				resumeEnabled: resume !== "never" && gepaRecipeSupportsResume(config.recipe)
-			});
-			const runBudget = openExternalOptimizerRunBudget({
-				storage,
-				runDir,
-				runKey: runId,
-				attemptId,
-				maxEvaluations: evaluationLimit
-			});
-			const observationLog = openExternalOptimizerObservationLog({
-				storage,
-				path: `${runDir}/observations-${attemptId}.jsonl`
-			});
-			const executionLog = config.optimizer ? openExternalOptimizerExecutionLog({
-				storage,
-				path: `${runDir}/model-executions-${attemptId}.jsonl`
-			}) : void 0;
-			const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "GEPA bridge");
-			const evaluate = createExternalTextEvaluator({
-				input,
-				label: "GEPA bridge",
-				runDir,
-				compatibleRunId: runId,
-				costPhase: "gepa.external-evaluation",
-				costTags: runBudget.attemptTags,
-				costLedger,
-				scenarioById,
-				maxCandidateChars,
-				maxEvidenceChars,
-				describeArtifact: config.describeArtifact
-			});
-			let attemptEvaluationCount = 0;
-			const callback = await startExternalOptimizerCallback({
-				token: randomBytes(32).toString("hex"),
-				maxEvaluations: evaluationLimit,
-				acceptEvaluation: () => {
-					if (runBudget.acceptEvaluation() === void 0) return void 0;
-					attemptEvaluationCount += 1;
-					return attemptEvaluationCount;
-				},
-				evaluate,
-				observe: observationLog.observe,
-				...config.evaluationCallbackLimits ? { limits: config.evaluationCallbackLimits } : {},
-				...signal ? { signal } : {}
-			});
-			const runnerEnv = bridgeRunner?.env ?? {};
-			let modelProxy;
-			const bridgeRunnerForSpawn = () => {
-				if (!modelProxy) return bridgeRunner;
-				const anthropicChildEnv = config.optimizer?.anthropicEndpoint === true && gepaRecipeHasAgentCliEngine(config.recipe) ? anthropicShimEnvironment(modelProxy, config.optimizer) : void 0;
-				if (!bridgeRunner && !anthropicChildEnv) return bridgeRunner;
-				return {
-					...bridgeRunner ?? {},
-					env: {
-						...removeCredentialEnvironment(runnerEnv),
-						...anthropicChildEnv ?? {}
-					}
-				};
-			};
-			const closeResources = () => closeExternalOptimizerResources({
-				label: name,
-				callback,
-				...modelProxy ? { modelProxy } : {}
-			});
-			const { result, outputDir } = await runWithCleanup({
-				label: `${name} optimizer resources`,
-				run: async () => {
-					if (config.optimizer) {
-						const priorOptimizerUsage = costLedger.summary({
-							phase: "gepa.optimizer-model",
-							tags: runBudget.runTags
-						});
-						assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
-						modelProxy = await startExternalOptimizerModelProxy({
-							call: config.optimizer.call,
-							callRef: config.optimizer.callRef,
-							recordExecution: executionLog.observe,
-							model: config.optimizer.model,
-							budget: config.optimizer.budget,
-							...config.optimizer.servedModelPolicy ? { servedModelPolicy: config.optimizer.servedModelPolicy } : {},
-							...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {},
-							costLedger,
-							phase: "gepa.optimizer-model",
-							actor: name,
-							tags: { ...runBudget.attemptTags },
-							initialUsage: {
-								requests: priorOptimizerUsage.totalCalls,
-								...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
-							},
-							...signal ? { signal } : {}
-						});
-					}
-					const outputDir = `${runDir}/external`;
-					await mkdir(outputDir, { recursive: true });
-					return {
-						result: await runExternalOptimizerProcess({
-							label: "GEPA bridge",
-							tempPrefix: "agent-eval-gepa-",
-							module: "agent_eval_rpc.gepa_bridge",
-							input: {
-								attemptId,
-								compatibleRunId,
-								runId,
-								runtimeIdentity,
-								resume,
-								trustedResumeState: config.trustResumeState === true,
-								evaluationId: config.evaluationId,
-								seed: input.seed,
-								callbackUrl: callback.url,
-								callbackToken: callback.token,
-								timeoutMs,
-								engineModules: config.engineModules ?? [],
-								recipe: config.recipe,
-								objective: config.objective,
-								...config.background ? { background: config.background } : {},
-								seedCandidate,
-								trainSet,
-								selectionSet,
-								maxCandidateChars,
-								maxPopulationCandidates,
-								maxEvidenceChars,
-								outputDir,
-								...modelProxy && config.optimizer ? { modelProxy: {
-									baseUrl: modelProxy.baseUrl,
-									apiKey: modelProxy.apiKey,
-									model: config.optimizer.model,
-									budget: config.optimizer.budget,
-									...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {}
-								} } : {}
-							},
-							runner: bridgeRunnerForSpawn(),
-							timeoutMs,
-							...signal ? { signal } : {}
-						}),
-						outputDir
-					};
-				},
-				cleanup: closeResources
-			});
-			signal?.throwIfAborted();
-			assertGepaBridgeOutput(result, name, maxCandidateChars, config.recipe.kind, evaluationLimit, maxPopulationCandidates, populationScenarioIds, expectsComponents, config.recipe.kind === "engine" && config.recipe.run.engine === "gepa");
-			assertExternalOptimizerRunBinding({
-				label: name,
-				runtime: runtimeIdentity,
-				returnedSource: result.upstream,
-				compatibleRunId,
-				runId,
-				returnedRunId: result.runId,
-				resume,
-				resumed: result.resumed
-			});
-			if (callback.evaluations() !== result.totalEvaluations) throw new Error(`${name}: GEPA reported ${result.totalEvaluations} evaluations but the callback received ${callback.evaluations()}`);
-			const population = result.candidatePopulation ? readGepaCandidatePopulationArtifact({
-				summary: result.candidatePopulation,
-				storage
-			}) : null;
-			if (population) {
-				const selected = population.candidates[population.bestIndex];
-				const selectedHash = contentHash({
-					kind: "external-text-candidate",
-					candidate: result.bestCandidate
+					...config.optimizer.servedModelPolicy ? { servedModelPolicy: config.optimizer.servedModelPolicy } : {},
+					...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {},
+					costLedger,
+					phase: "gepa.optimizer-model",
+					actor: name,
+					tags: { ...runBudget.attemptTags },
+					initialUsage: {
+						requests: priorOptimizerUsage.totalCalls,
+						...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
+					},
+					...signal ? { signal } : {}
 				});
-				if (selected?.candidateHash !== selectedHash) throw new Error(`${name}: GEPA candidate population identifies a different winner`);
 			}
-			const searchHistory = config.searchLedger ? await recordGepaSearch({
-				name,
-				path: config.searchLedger.path ?? `${runDir}/search-ledger.jsonl`,
-				searchId: runId,
-				identity: config.searchLedger.identity,
-				storage,
-				seed: input.seed,
-				baselineSurface: input.baselineSurface,
-				trainScenarios: input.trainScenarios,
-				selectionScenarios: input.selectionScenarios,
-				evaluationLimit,
-				...population ? { population } : {
-					population: null,
-					selected: decodeExternalTextCandidate(result.bestCandidate)
-				},
-				observations: readExternalOptimizerObservationArtifact({
-					summary: observationLog.summary(),
-					storage
-				}),
-				generationAccounting: optimizerAccounting(result.tokenUsage, result.proposerCostUsd)
-			}) : void 0;
-			const evaluationCost = costFromLedgerSummary(costLedger.summary({
-				phase: "gepa.external-evaluation",
-				tags: runBudget.runTags
-			}));
-			const optimizerSummary = costLedger.summary({
-				phase: "gepa.optimizer-model",
-				tags: runBudget.runTags
-			});
-			const optimizerReceipts = costLedger.list({
-				phase: "gepa.optimizer-model",
-				tags: runBudget.runTags
-			});
-			const optimizerCost = costFromLedgerSummary(optimizerSummary);
-			const reportedProposerCost = result.proposerCostUsd ?? 0;
-			if (modelProxy) {
-				modelProxy.assertExecutionComplete();
-				const wires = modelProxy.wireUsage();
-				assertExternalOptimizerCompletionCount(result.tokenUsage, wires.openai.requestAttempts, wires.openai.successfulCompletions, name, "GEPA");
-				if (config.optimizer?.anthropicEndpoint === true) {
-					const anthropicReceipts = costLedger.list({
-						phase: "gepa.optimizer-model",
-						tags: {
-							...runBudget.attemptTags,
-							wire: "anthropic"
-						}
-					});
-					if (anthropicReceipts.length !== wires.anthropic.requestAttempts) throw new Error(`${name}: the Anthropic endpoint admitted ${wires.anthropic.requestAttempts} model calls but the ledger holds ${anthropicReceipts.length} receipts`);
-				}
-			}
-			const tokenUsage = modelProxy ? optimizationTokenUsageFromSummary(optimizerSummary, optimizerReceipts) : void 0;
-			const runtime = observedExternalOptimizerRuntime(runtimeIdentity);
-			const meteredCost = modelProxy ? combineComparisonCosts([{
-				label: "evaluation",
-				cost: evaluationCost
-			}, {
-				label: "optimizer model",
-				cost: optimizerCost
-			}]) : void 0;
-			const externalTotalCostUsd = evaluationCost.totalCostUsd + reportedProposerCost;
+			const outputDir = `${runDir}/external`;
+			await mkdir(outputDir, { recursive: true });
 			return {
-				winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
-				...searchHistory ? { searchHistory } : {},
-				cost: modelProxy ? meteredCost : {
-					totalCostUsd: externalTotalCostUsd,
-					costProvenance: result.proposerCostAccounting === "reported" && evaluationCost.costProvenance.kind !== "uncaptured" ? {
-						kind: "estimated",
-						usd: externalTotalCostUsd
-					} : {
-						kind: "uncaptured",
-						usd: null
+				result: await runExternalOptimizerProcess({
+					label: "GEPA bridge",
+					tempPrefix: "agent-eval-gepa-",
+					module: "agent_eval_rpc.gepa_bridge",
+					input: {
+						attemptId,
+						compatibleRunId,
+						runId,
+						runtimeIdentity,
+						resume,
+						trustedResumeState: config.trustResumeState === true,
+						evaluationId: config.evaluationId,
+						seed: input.seed,
+						callbackUrl: callback.url,
+						callbackToken: callback.token,
+						timeoutMs,
+						engineModules: config.engineModules ?? [],
+						recipe: config.recipe,
+						objective: config.objective,
+						...config.background ? { background: config.background } : {},
+						seedCandidate,
+						trainSet,
+						selectionSet,
+						maxCandidateChars,
+						maxPopulationCandidates,
+						maxEvidenceChars,
+						outputDir,
+						...modelProxy && config.optimizer ? { modelProxy: {
+							baseUrl: modelProxy.baseUrl,
+							apiKey: modelProxy.apiKey,
+							model: config.optimizer.model,
+							budget: config.optimizer.budget,
+							...config.optimizer.anthropicEndpoint === true ? { anthropicEndpoint: true } : {}
+						} } : {}
 					},
-					accountingComplete: false,
-					incompleteReasons: [
-						...evaluationCost.incompleteReasons,
-						result.proposerCostAccounting === "reported" ? "GEPA proposer cost is externally reported and has no agent-eval receipt" : "GEPA proposer cost is unavailable",
-						...result.resumed ? ["GEPA proposer cost before this resumed attempt is unavailable"] : []
-					]
-				},
-				durationMs: Date.now() - started,
-				provenance: {
-					...runtime,
-					...config.optimizer ? {
-						optimizerModel: config.optimizer.model,
-						optimizerCallRef: config.optimizer.callRef
-					} : {},
-					...modelProxy && config.optimizer?.anthropicEndpoint === true ? { anthropicEndpoint: modelProxy.wireUsage().anthropic } : {},
-					compatibleRunId,
-					runId,
-					resumed: result.resumed,
-					seedApplied: result.seedApplied,
-					evaluationCount: runBudget.acceptedEvaluations(),
-					...result.upstreamReportedEvaluations !== void 0 ? { upstreamReportedEvaluations: result.upstreamReportedEvaluations } : {},
-					artifactDir: outputDir,
-					...tokenUsage ? { tokenUsage } : {},
-					observations: observationLog.summary(),
-					...result.candidatePopulation ? { gepaCandidatePopulation: result.candidatePopulation } : {},
-					...executionLog ? { modelExecutions: executionLog.summary() } : {}
+					runner: bridgeRunnerForSpawn(),
+					timeoutMs,
+					...signal ? { signal } : {}
+				}),
+				outputDir
+			};
+		},
+		cleanup: closeResources
+	});
+	return {
+		result,
+		outputDir,
+		modelProxy
+	};
+}
+/** Check the bridge output against the run it was started for, and return the candidate population it reports. */
+function verifyBridgeResult(ctx, result) {
+	const { signal, expectsComponents, maxCandidateChars, storage, resume, runtimeIdentity, evaluationLimit, maxPopulationCandidates, populationScenarioIds, compatibleRunId, runId, callback, name, config } = ctx;
+	signal?.throwIfAborted();
+	assertGepaBridgeOutput(result, name, maxCandidateChars, config.recipe.kind, evaluationLimit, maxPopulationCandidates, populationScenarioIds, expectsComponents, config.recipe.kind === "engine" && config.recipe.run.engine === "gepa");
+	assertExternalOptimizerRunBinding({
+		label: name,
+		runtime: runtimeIdentity,
+		returnedSource: result.upstream,
+		compatibleRunId,
+		runId,
+		returnedRunId: result.runId,
+		resume,
+		resumed: result.resumed
+	});
+	if (callback.evaluations() !== result.totalEvaluations) throw new Error(`${name}: GEPA reported ${result.totalEvaluations} evaluations but the callback received ${callback.evaluations()}`);
+	const population = result.candidatePopulation ? readGepaCandidatePopulationArtifact({
+		summary: result.candidatePopulation,
+		storage
+	}) : null;
+	if (population) {
+		const selected = population.candidates[population.bestIndex];
+		const selectedHash = contentHash({
+			kind: "external-text-candidate",
+			candidate: result.bestCandidate
+		});
+		if (selected?.candidateHash !== selectedHash) throw new Error(`${name}: GEPA candidate population identifies a different winner`);
+	}
+	return population;
+}
+/** Every recipe records its search in the search ledger when one is configured. */
+async function recordGepaSearchHistory(ctx, result, population) {
+	const { storage, runDir, evaluationLimit, runId, observationLog, name, config, input } = ctx;
+	return config.searchLedger ? await recordGepaSearch({
+		name,
+		path: config.searchLedger.path ?? `${runDir}/search-ledger.jsonl`,
+		searchId: runId,
+		identity: config.searchLedger.identity,
+		storage,
+		seed: input.seed,
+		baselineSurface: input.baselineSurface,
+		trainScenarios: input.trainScenarios,
+		selectionScenarios: input.selectionScenarios,
+		evaluationLimit,
+		...population ? { population } : {
+			population: null,
+			selected: decodeExternalTextCandidate(result.bestCandidate)
+		},
+		observations: readExternalOptimizerObservationArtifact({
+			summary: observationLog.summary(),
+			storage
+		}),
+		generationAccounting: optimizerAccounting(result.tokenUsage, result.proposerCostUsd)
+	}) : void 0;
+}
+/** Evaluation and optimizer-model cost, with the proxy's completeness checks. */
+function gepaCosts(ctx, result, modelProxy) {
+	const { costLedger, runtimeIdentity, runBudget, name, config } = ctx;
+	const evaluationCost = costFromLedgerSummary(costLedger.summary({
+		phase: "gepa.external-evaluation",
+		tags: runBudget.runTags
+	}));
+	const optimizerSummary = costLedger.summary({
+		phase: "gepa.optimizer-model",
+		tags: runBudget.runTags
+	});
+	const optimizerReceipts = costLedger.list({
+		phase: "gepa.optimizer-model",
+		tags: runBudget.runTags
+	});
+	const optimizerCost = costFromLedgerSummary(optimizerSummary);
+	const reportedProposerCost = result.proposerCostUsd ?? 0;
+	if (modelProxy) {
+		modelProxy.assertExecutionComplete();
+		const wires = modelProxy.wireUsage();
+		assertExternalOptimizerCompletionCount(result.tokenUsage, wires.openai.requestAttempts, wires.openai.successfulCompletions, name, "GEPA");
+		if (config.optimizer?.anthropicEndpoint === true) {
+			const anthropicReceipts = costLedger.list({
+				phase: "gepa.optimizer-model",
+				tags: {
+					...runBudget.attemptTags,
+					wire: "anthropic"
 				}
-			};
+			});
+			if (anthropicReceipts.length !== wires.anthropic.requestAttempts) throw new Error(`${name}: the Anthropic endpoint admitted ${wires.anthropic.requestAttempts} model calls but the ledger holds ${anthropicReceipts.length} receipts`);
 		}
+	}
+	return {
+		evaluationCost,
+		tokenUsage: modelProxy ? optimizationTokenUsageFromSummary(optimizerSummary, optimizerReceipts) : void 0,
+		runtime: observedExternalOptimizerRuntime(runtimeIdentity),
+		meteredCost: modelProxy ? combineComparisonCosts([{
+			label: "evaluation",
+			cost: evaluationCost
+		}, {
+			label: "optimizer model",
+			cost: optimizerCost
+		}]) : void 0,
+		externalTotalCostUsd: evaluationCost.totalCostUsd + reportedProposerCost
 	};
 }
-/** Spend the optimizer booked to its own candidate generation. Unknown stays
-*  unknown: the bridge reports proposer cost only when the engine measured it. */
-function optimizerAccounting(tokenUsage, proposerCostUsd) {
+/** The method result: the winning surface, its cost and the provenance of the run. */
+function buildGepaOutcome(ctx, result, outputDir, modelProxy, searchHistory, costs) {
+	const { started, compatibleRunId, runId, runBudget, observationLog, executionLog, config } = ctx;
+	const { evaluationCost, tokenUsage, runtime, meteredCost, externalTotalCostUsd } = costs;
 	return {
-		tokens: tokenUsage?.inputTokens === void 0 || tokenUsage.outputTokens === void 0 ? {
-			status: "unknown",
-			reason: "the optimizer bridge reported no token usage"
-		} : {
-			status: "known",
-			inputTokens: tokenUsage.inputTokens,
-			outputTokens: tokenUsage.outputTokens,
-			cachedTokens: 0
+		winnerSurface: decodeExternalTextCandidate(result.bestCandidate),
+		...searchHistory ? { searchHistory } : {},
+		cost: modelProxy ? meteredCost : {
+			totalCostUsd: externalTotalCostUsd,
+			costProvenance: result.proposerCostAccounting === "reported" && evaluationCost.costProvenance.kind !== "uncaptured" ? {
+				kind: "estimated",
+				usd: externalTotalCostUsd
+			} : {
+				kind: "uncaptured",
+				usd: null
+			},
+			accountingComplete: false,
+			incompleteReasons: [
+				...evaluationCost.incompleteReasons,
+				result.proposerCostAccounting === "reported" ? "GEPA proposer cost is externally reported and has no agent-eval receipt" : "GEPA proposer cost is unavailable",
+				...result.resumed ? ["GEPA proposer cost before this resumed attempt is unavailable"] : []
+			]
 		},
-		cost: proposerCostUsd === void 0 ? {
-			status: "unknown",
-			knownLowerBoundUsd: 0,
-			reason: "the optimizer bridge reported no proposer cost"
-		} : {
-			status: "known",
-			usd: proposerCostUsd,
-			source: "provider"
+		durationMs: Date.now() - started,
+		provenance: {
+			...runtime,
+			...config.optimizer ? {
+				optimizerModel: config.optimizer.model,
+				optimizerCallRef: config.optimizer.callRef
+			} : {},
+			...modelProxy && config.optimizer?.anthropicEndpoint === true ? { anthropicEndpoint: modelProxy.wireUsage().anthropic } : {},
+			compatibleRunId,
+			runId,
+			resumed: result.resumed,
+			seedApplied: result.seedApplied,
+			evaluationCount: runBudget.acceptedEvaluations(),
+			...result.upstreamReportedEvaluations !== void 0 ? { upstreamReportedEvaluations: result.upstreamReportedEvaluations } : {},
+			artifactDir: outputDir,
+			...tokenUsage ? { tokenUsage } : {},
+			observations: observationLog.summary(),
+			...result.candidatePopulation ? { gepaCandidatePopulation: result.candidatePopulation } : {},
+			...executionLog ? { modelExecutions: executionLog.summary() } : {}
+		}
+	};
+}
+//#endregion
+//#region src/campaign/gepa-optimization-method.ts
+/**
+* Turn an optional GEPA installation into an `OptimizationMethod`.
+*
+* GEPA receives only serialized train and selection cases. The caller's final
+* test partition stays inside `compareOptimizationMethods`, which invokes this
+* method without a test-set field. The local callback routes every candidate
+* evaluation through the same dispatch and judges used by other methods.
+*/
+/**
+* Environment for a bridge child that spawns `claude` CLI subprocesses.
+*
+* Both agent CLI engines start the CLI with the bridge's own environment, so
+* these variables travel bridge → engine → CLI. They merge AFTER
+* `removeCredentialEnvironment`: the ephemeral loopback token is the only
+* credential the child may see, and a caller-supplied ANTHROPIC_AUTH_TOKEN is
+* stripped like any other credential.
+*/
+function gepaOptimizationMethod(config) {
+	assertGepaOptimizationConfig(config);
+	config = snapshotGepaOptimizationConfig(config);
+	const name = config.name ?? defaultGepaMethodName(config.recipe);
+	return {
+		name,
+		async optimize(input) {
+			const ctx = await prepareGepaRun(config, input, name);
+			const { result, outputDir, modelProxy } = await runBridge(ctx);
+			return buildGepaOutcome(ctx, result, outputDir, modelProxy, await recordGepaSearchHistory(ctx, result, verifyBridgeResult(ctx, result)), gepaCosts(ctx, result, modelProxy));
 		}
 	};
 }
 //#endregion
+//#region src/campaign/presets/comparison-controls.ts
+/** Admission checks for the shared controls of a method comparison. */
+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)}`);
+	assertConfidence(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 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);
+}
+//#endregion
 //#region src/campaign/presets/compare-optimization-methods.ts
 /**
 * Compare optimization methods on shared train, selection, and test data.
@@ -2140,16 +2325,21 @@ function optimizerAccounting(tokenUsage, proposerCostUsd) {
 /**
 * 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)
+async function compareOptimizationMethods(rawOpts) {
+	return comparisonResult(pairwiseAgainstBest(scoreMethods(await measureWinners(await reserveTestMeasurement(await optimizeAllMethods(await finalTestScoring(normalizeComparisonOptions({ rawOpts }))))))));
+}
+/** The captured options, the derived statistics settings, the run directory and the cost ledger. */
+function normalizeComparisonOptions(prev) {
+	const { rawOpts } = prev;
+	const opts = {
+		...rawOpts,
+		methods: rawOpts.methods.map((method) => ({ ...method })),
+		trainScenarios: structuredClone(rawOpts.trainScenarios),
+		selectionScenarios: structuredClone(rawOpts.selectionScenarios),
+		testScenarios: structuredClone(rawOpts.testScenarios),
+		judges: rawOpts.judges.map(captureJudge),
+		claim: rawOpts.claim && defineEvaluationClaim(rawOpts.claim),
+		finalEvidence: rawOpts.finalEvidence && captureFinalEvidencePolicy(rawOpts.finalEvidence)
 	};
 	assertOptimizationMethods(opts.methods);
 	assertComparisonPartitions(opts);
@@ -2174,6 +2364,28 @@ async function compareOptimizationMethods(opts) {
 		runDir: `${resolvedRunDir}/cost`,
 		costCeilingUsd: opts.costCeiling
 	});
+	return {
+		...prev,
+		opts,
+		searchHistoryPolicy,
+		seed,
+		confidence,
+		optimizationConcurrency,
+		comparisonCount,
+		intervalConfidence,
+		minimumResamples,
+		resamples,
+		evidence,
+		evidenceBySurface,
+		storage,
+		resolvedRunDir,
+		baselineSurface,
+		costLedger
+	};
+}
+/** Scoring a surface on the final test set, and aligning the scores to the designed scenarios. */
+async function finalTestScoring(prev) {
+	const { opts, seed, intervalConfidence, resamples, evidence, evidenceBySurface, storage, resolvedRunDir, costLedger } = prev;
 	const scoreOnTest = async (surface, tag, costPhase) => {
 		const measuredSurface = structuredClone(surface);
 		const campaign = await runCampaign({
@@ -2227,6 +2439,20 @@ async function compareOptimizationMethods(opts) {
 		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]);
 	};
+	return {
+		...prev,
+		scoreOnTest,
+		scenarioIds,
+		unitByScenario,
+		units,
+		aggregateUnits,
+		decisionOptions,
+		align
+	};
+}
+/** Reserve final evidence, then finish every method before the first final-test call. */
+async function optimizeAllMethods(prev) {
+	const { opts, seed, optimizationConcurrency, storage, resolvedRunDir, baselineSurface, costLedger } = prev;
 	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();
@@ -2258,7 +2484,16 @@ async function compareOptimizationMethods(opts) {
 		label: `method '${result.name}'`,
 		cost: result.cost
 	}))).totalCostUsd, opts.costCeiling, "optimization");
-	const testCostPhase = `compareOptimizationMethods.test:${contentHash({
+	return {
+		...prev,
+		optimizationOwner,
+		optimized
+	};
+}
+/** The identity of the final test and the exposure of its evidence. */
+async function reserveTestMeasurement(prev) {
+	const { opts, seed, baselineSurface, optimized } = prev;
+	const testCostIdentity = contentHash({
 		baseline: surfaceContentHash(baselineSurface),
 		winners: optimized.map((winner) => ({
 			name: winner.name,
@@ -2276,8 +2511,19 @@ async function compareOptimizationMethods(opts) {
 		dispatch: callerDispatchRef(opts),
 		seed,
 		reps: opts.reps ?? 1
-	})}`;
+	});
+	const testCostPhase = `compareOptimizationMethods.test:${testCostIdentity}`;
 	const finalEvidence = opts.finalEvidence ? await exposeFinalEvidence(opts.finalEvidence, opts.claim, opts.testScenarios, [baselineSurface, ...optimized.map((method) => method.winnerSurface)]) : void 0;
+	return {
+		...prev,
+		testCostIdentity,
+		testCostPhase,
+		finalEvidence
+	};
+}
+/** One final-test measurement per distinct surface. */
+async function measureWinners(prev) {
+	const { baselineSurface, scoreOnTest, align, optimized, testCostPhase } = prev;
 	const baselineArr = align(await scoreOnTest(baselineSurface, "test/baseline", testCostPhase), "baseline");
 	const testScoresBySurface = /* @__PURE__ */ new Map([[surfaceContentHash(baselineSurface), baselineArr]]);
 	const winners = [];
@@ -2293,6 +2539,16 @@ async function compareOptimizationMethods(opts) {
 			arr
 		});
 	}
+	return {
+		...prev,
+		baselineArr,
+		testScoresBySurface,
+		winners
+	};
+}
+/** Per-method scores, ranked by lift with cost breaking complete ties. */
+function scoreMethods(prev) {
+	const { evidence, evidenceBySurface, baselineSurface, scenarioIds, units, aggregateUnits, decisionOptions, baselineArr, winners } = prev;
 	const scores = winners.map((w) => {
 		const baselineUnits = aggregateUnits(baselineArr);
 		const winnerUnits = aggregateUnits(w.arr);
@@ -2353,6 +2609,15 @@ async function compareOptimizationMethods(opts) {
 		s.rank = i + 1;
 	});
 	const best = scores[0];
+	return {
+		...prev,
+		scores,
+		best
+	};
+}
+/** The best method against every other, in both directions. */
+function pairwiseAgainstBest(prev) {
+	const { aggregateUnits, decisionOptions, winners, scores, best } = prev;
 	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) => {
@@ -2370,6 +2635,16 @@ async function compareOptimizationMethods(opts) {
 			decision
 		};
 	});
+	return {
+		...prev,
+		byName,
+		bestArr,
+		pairwise
+	};
+}
+/** Total cost against the ceiling, then the comparison record. */
+function comparisonResult(prev) {
+	const { opts, searchHistoryPolicy, seed, confidence, comparisonCount, intervalConfidence, resamples, costLedger, scenarioIds, units, optimized, testCostPhase, finalEvidence, scores, best, pairwise } = prev;
 	const optimizationCost = combineComparisonCosts(scores.map((score) => ({
 		label: `method '${score.name}'`,
 		cost: score.optimizationCost
@@ -2431,43 +2706,6 @@ function assertOptimizationMethods(methods) {
 		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)}`);
-	assertConfidence(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 = [
 		{
@@ -2508,13 +2746,6 @@ function assertComparisonPartitions(opts) {
 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);
@@ -2626,298 +2857,347 @@ function assertSkillOptBridgeOutput(result, name, maxCandidateChars, maxEvaluati
 function skillOptOptimizationMethod(config) {
 	assertSkillOptOptimizationConfig(config);
 	config = snapshotSkillOptOptimizationConfig(config);
-	const name = config.name ?? "skillopt";
+	const snapshot = config;
+	const name = snapshot.name ?? "skillopt";
 	return {
 		name,
-		async optimize(input) {
-			const signal = input.runOptions.signal;
-			signal?.throwIfAborted();
-			if (typeof input.baselineSurface !== "string") throw new Error(`${name}: SkillOpt requires a string baselineSurface`);
-			const started = Date.now();
-			const maxCandidateChars = config.maxCandidateChars ?? 2e5;
-			const maxEvidenceChars = config.maxEvidenceChars ?? 1e5;
-			const storage = input.runOptions.storage ?? fsCampaignStorage();
-			const runDir = `${input.runDir}/skillopt`;
-			storage.ensureDir(runDir);
-			const costLedger = input.costLedger;
-			const attemptId = randomBytes(16).toString("hex");
-			const resume = config.resume ?? "never";
-			const bridgeRunner = config.runner ? {
-				...config.runner,
-				env: removeCredentialEnvironment(config.runner.env ?? {})
-			} : void 0;
-			const runtimeIdentity = await inspectExternalOptimizerRuntime({
-				label: name,
-				package: "skillopt",
-				module: "agent_eval_rpc.skillopt_bridge",
-				...bridgeRunner ? { runner: bridgeRunner } : {},
-				timeoutMs: config.timeoutMs ?? 36e5,
-				...signal ? { signal } : {}
-			});
-			const trainSet = input.trainScenarios.map((scenario) => describeExternalScenario(scenario, "SkillOpt", maxEvidenceChars, config.describeScenario));
-			const selectionSet = input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, "SkillOpt", maxEvidenceChars, config.describeScenario));
-			const runMaterial = {
-				optimizer: "skillopt",
-				runtime: runtimeIdentity,
-				method: name,
-				evaluationId: config.evaluationId,
-				dispatchRef: input.runOptions.dispatchRef ?? null,
-				seed: input.seed,
-				trainer: snapshotJson(config.trainer, "SkillOpt run settings"),
-				objective: config.objective,
-				background: config.background ?? "",
-				optimizerModel: {
-					model: config.optimizer.model,
-					callRef: config.optimizer.callRef,
-					budget: config.optimizer.budget
-				},
-				seedCandidate: input.baselineSurface,
-				trainSet,
-				selectionSet,
-				maxEvaluations: config.maxEvaluations,
-				hardScoreThreshold: config.hardScoreThreshold ?? 1,
-				maxCandidateChars,
-				maxEvidenceChars,
-				evaluationCallbackLimits: resolveExternalOptimizerCallbackLimits(config.evaluationCallbackLimits),
-				runner: externalOptimizerRunnerIdentity(bridgeRunner, "agent_eval_rpc.skillopt_bridge")
-			};
-			const compatibleRunId = externalOptimizerCompatibleRunKey(runMaterial);
-			const runId = externalOptimizerRunKey({
-				material: runMaterial,
-				attemptId,
-				resumeEnabled: resume !== "never"
-			});
-			const runBudget = openExternalOptimizerRunBudget({
-				storage,
-				runDir,
-				runKey: runId,
-				attemptId,
-				maxEvaluations: config.maxEvaluations
-			});
-			const observationLog = openExternalOptimizerObservationLog({
-				storage,
-				path: `${runDir}/observations-${attemptId}.jsonl`
-			});
-			const executionLog = openExternalOptimizerExecutionLog({
-				storage,
-				path: `${runDir}/model-executions-${attemptId}.jsonl`
-			});
-			const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "SkillOpt bridge");
-			const evaluate = createExternalTextEvaluator({
-				input,
-				label: "SkillOpt bridge",
-				runDir,
-				compatibleRunId: runId,
-				costPhase: "skillopt.external-evaluation",
-				costTags: runBudget.attemptTags,
-				costLedger,
-				scenarioById,
-				maxCandidateChars,
-				maxEvidenceChars,
-				describeArtifact: config.describeArtifact
-			});
-			let attemptEvaluationCount = 0;
-			const callback = await startExternalOptimizerCallback({
-				token: randomBytes(32).toString("hex"),
-				maxEvaluations: config.maxEvaluations,
-				acceptEvaluation: () => {
-					if (runBudget.acceptEvaluation() === void 0) return void 0;
-					attemptEvaluationCount += 1;
-					return attemptEvaluationCount;
-				},
-				evaluate,
-				observe: observationLog.observe,
-				...config.evaluationCallbackLimits ? { limits: config.evaluationCallbackLimits } : {},
-				...signal ? { signal } : {}
-			});
-			const runnerEnv = bridgeRunner?.env ?? {};
-			let activeModelProxy;
-			const closeResources = () => closeExternalOptimizerResources({
-				label: name,
-				callback,
-				...activeModelProxy ? { modelProxy: activeModelProxy } : {}
-			});
-			const { result, outputDir, modelProxy } = await runWithCleanup({
-				label: `${name} optimizer resources`,
-				run: async () => {
-					const priorOptimizerUsage = costLedger.summary({
-						phase: "skillopt.optimizer-model",
-						tags: runBudget.runTags
-					});
-					assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
-					const modelProxy = await startExternalOptimizerModelProxy({
-						call: config.optimizer.call,
-						callRef: config.optimizer.callRef,
-						recordExecution: executionLog.observe,
-						model: config.optimizer.model,
-						budget: config.optimizer.budget,
-						...config.optimizer.servedModelPolicy ? { servedModelPolicy: config.optimizer.servedModelPolicy } : {},
-						costLedger,
-						phase: "skillopt.optimizer-model",
-						actor: name,
-						tags: { ...runBudget.attemptTags },
-						initialUsage: {
-							requests: priorOptimizerUsage.totalCalls,
-							...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
-						},
-						...signal ? { signal } : {}
-					});
-					activeModelProxy = modelProxy;
-					const outputDir = `${runDir}/external`;
-					await mkdir(outputDir, { recursive: true });
-					return {
-						result: await runExternalOptimizerProcess({
-							label: "SkillOpt bridge",
-							tempPrefix: "agent-eval-skillopt-",
-							module: "agent_eval_rpc.skillopt_bridge",
-							input: {
-								attemptId,
-								compatibleRunId,
-								runId,
-								runtimeIdentity,
-								resume,
-								evaluationId: config.evaluationId,
-								seed: input.seed,
-								callbackUrl: callback.url,
-								callbackToken: callback.token,
-								objective: config.objective,
-								...config.background ? { background: config.background } : {},
-								trainer: config.trainer,
-								optimizerModel: config.optimizer.model,
-								modelBudget: config.optimizer.budget,
-								seedCandidate: input.baselineSurface,
-								trainSet,
-								selectionSet,
-								maxEvaluations: config.maxEvaluations,
-								hardScoreThreshold: config.hardScoreThreshold ?? 1,
-								maxCandidateChars,
-								maxEvidenceChars,
-								outputDir
-							},
-							runner: {
-								...bridgeRunner,
-								env: {
-									...removeCredentialEnvironment(runnerEnv),
-									OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
-									OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
-									OPTIMIZER_OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
-									OPTIMIZER_OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
-									TARGET_OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
-									TARGET_OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
-									OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
-									OPENAI_COMPATIBLE_MAX_TOKENS: String(config.optimizer.budget.maxOutputTokensPerRequest),
-									OPTIMIZER_OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
-									OPTIMIZER_OPENAI_COMPATIBLE_MAX_TOKENS: String(config.optimizer.budget.maxOutputTokensPerRequest),
-									TARGET_OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
-									TARGET_OPENAI_COMPATIBLE_MAX_TOKENS: String(config.optimizer.budget.maxOutputTokensPerRequest)
-								}
-							},
-							timeoutMs: config.timeoutMs ?? 36e5,
-							...signal ? { signal } : {}
-						}),
-						outputDir,
-						modelProxy
-					};
-				},
-				cleanup: closeResources
-			});
-			signal?.throwIfAborted();
-			assertSkillOptBridgeOutput(result, name, maxCandidateChars, config.maxEvaluations);
-			assertExternalOptimizerRunBinding({
-				label: name,
-				runtime: runtimeIdentity,
-				returnedSource: result.upstream,
-				compatibleRunId,
-				runId,
-				returnedRunId: result.runId,
-				resume,
-				resumed: result.resumed
-			});
-			if (callback.evaluations() !== result.totalEvaluations) throw new Error(`${name}: SkillOpt reported ${result.totalEvaluations} evaluations but the callback received ${callback.evaluations()}`);
-			const evaluationCost = costFromLedgerSummary(costLedger.summary({
-				phase: "skillopt.external-evaluation",
-				tags: runBudget.runTags
-			}));
-			const optimizerUsage = costLedger.summary({
+		optimize: (input) => optimizeWithSkillOpt(snapshot, name, input)
+	};
+}
+async function optimizeWithSkillOpt(config, name, input) {
+	const signal = input.runOptions.signal;
+	signal?.throwIfAborted();
+	if (typeof input.baselineSurface !== "string") throw new Error(`${name}: SkillOpt requires a string baselineSurface`);
+	const context = await prepareSkillOptRun(config, name, input);
+	const { result, outputDir, modelProxy } = await runSkillOptBridge(context);
+	signal?.throwIfAborted();
+	return finishSkillOptRun(context, result, outputDir, modelProxy);
+}
+/** Resolve identities, open the run's budget and logs, and start the evaluation callback. */
+async function prepareSkillOptRun(config, name, input) {
+	const signal = input.runOptions.signal;
+	const started = Date.now();
+	const maxCandidateChars = config.maxCandidateChars ?? 2e5;
+	const maxEvidenceChars = config.maxEvidenceChars ?? 1e5;
+	const storage = input.runOptions.storage ?? fsCampaignStorage();
+	const runDir = `${input.runDir}/skillopt`;
+	storage.ensureDir(runDir);
+	const costLedger = input.costLedger;
+	const attemptId = randomBytes(16).toString("hex");
+	const resume = config.resume ?? "never";
+	const bridgeRunner = config.runner ? {
+		...config.runner,
+		env: removeCredentialEnvironment(config.runner.env ?? {})
+	} : void 0;
+	const runtimeIdentity = await inspectExternalOptimizerRuntime({
+		label: name,
+		package: "skillopt",
+		module: "agent_eval_rpc.skillopt_bridge",
+		...bridgeRunner ? { runner: bridgeRunner } : {},
+		timeoutMs: config.timeoutMs ?? 36e5,
+		...signal ? { signal } : {}
+	});
+	const trainSet = input.trainScenarios.map((scenario) => describeExternalScenario(scenario, "SkillOpt", maxEvidenceChars, config.describeScenario));
+	const selectionSet = input.selectionScenarios.map((scenario) => describeExternalScenario(scenario, "SkillOpt", maxEvidenceChars, config.describeScenario));
+	const runMaterial = {
+		optimizer: "skillopt",
+		runtime: runtimeIdentity,
+		method: name,
+		evaluationId: config.evaluationId,
+		dispatchRef: input.runOptions.dispatchRef ?? null,
+		seed: input.seed,
+		trainer: snapshotJson(config.trainer, "SkillOpt run settings"),
+		objective: config.objective,
+		background: config.background ?? "",
+		optimizerModel: {
+			model: config.optimizer.model,
+			callRef: config.optimizer.callRef,
+			budget: config.optimizer.budget
+		},
+		seedCandidate: input.baselineSurface,
+		trainSet,
+		selectionSet,
+		maxEvaluations: config.maxEvaluations,
+		hardScoreThreshold: config.hardScoreThreshold ?? 1,
+		maxCandidateChars,
+		maxEvidenceChars,
+		evaluationCallbackLimits: resolveExternalOptimizerCallbackLimits(config.evaluationCallbackLimits),
+		runner: externalOptimizerRunnerIdentity(bridgeRunner, "agent_eval_rpc.skillopt_bridge")
+	};
+	const compatibleRunId = externalOptimizerCompatibleRunKey(runMaterial);
+	const runId = externalOptimizerRunKey({
+		material: runMaterial,
+		attemptId,
+		resumeEnabled: resume !== "never"
+	});
+	const runBudget = openExternalOptimizerRunBudget({
+		storage,
+		runDir,
+		runKey: runId,
+		attemptId,
+		maxEvaluations: config.maxEvaluations
+	});
+	const observationLog = openExternalOptimizerObservationLog({
+		storage,
+		path: `${runDir}/observations-${attemptId}.jsonl`
+	});
+	const executionLog = openExternalOptimizerExecutionLog({
+		storage,
+		path: `${runDir}/model-executions-${attemptId}.jsonl`
+	});
+	const scenarioById = mapExternalScenarios(input.trainScenarios, input.selectionScenarios, "SkillOpt bridge");
+	const evaluate = createExternalTextEvaluator({
+		input,
+		label: "SkillOpt bridge",
+		runDir,
+		compatibleRunId: runId,
+		costPhase: "skillopt.external-evaluation",
+		costTags: runBudget.attemptTags,
+		costLedger,
+		scenarioById,
+		maxCandidateChars,
+		maxEvidenceChars,
+		describeArtifact: config.describeArtifact
+	});
+	let attemptEvaluationCount = 0;
+	return {
+		config,
+		input,
+		name,
+		signal,
+		started,
+		maxCandidateChars,
+		maxEvidenceChars,
+		storage,
+		runDir,
+		attemptId,
+		resume,
+		bridgeRunner,
+		runtimeIdentity,
+		trainSet,
+		selectionSet,
+		compatibleRunId,
+		runId,
+		runBudget,
+		observationLog,
+		executionLog,
+		callback: await startExternalOptimizerCallback({
+			token: randomBytes(32).toString("hex"),
+			maxEvaluations: config.maxEvaluations,
+			acceptEvaluation: () => {
+				if (runBudget.acceptEvaluation() === void 0) return void 0;
+				attemptEvaluationCount += 1;
+				return attemptEvaluationCount;
+			},
+			evaluate,
+			observe: observationLog.observe,
+			...config.evaluationCallbackLimits ? { limits: config.evaluationCallbackLimits } : {},
+			...signal ? { signal } : {}
+		})
+	};
+}
+/** Start the metered model proxy and run the Python bridge, always closing the callback and proxy. */
+async function runSkillOptBridge(context) {
+	const { config, input, name, signal, runDir, runBudget, callback } = context;
+	const costLedger = input.costLedger;
+	const runnerEnv = context.bridgeRunner?.env ?? {};
+	let activeModelProxy;
+	const closeResources = () => closeExternalOptimizerResources({
+		label: name,
+		callback,
+		...activeModelProxy ? { modelProxy: activeModelProxy } : {}
+	});
+	return runWithCleanup({
+		label: `${name} optimizer resources`,
+		run: async () => {
+			const priorOptimizerUsage = costLedger.summary({
 				phase: "skillopt.optimizer-model",
 				tags: runBudget.runTags
 			});
-			const optimizerReceipts = costLedger.list({
+			assertPriorExternalOptimizerUsage(priorOptimizerUsage, config.optimizer.budget, name);
+			const modelProxy = await startExternalOptimizerModelProxy({
+				call: config.optimizer.call,
+				callRef: config.optimizer.callRef,
+				recordExecution: context.executionLog.observe,
+				model: config.optimizer.model,
+				budget: config.optimizer.budget,
+				...config.optimizer.servedModelPolicy ? { servedModelPolicy: config.optimizer.servedModelPolicy } : {},
+				costLedger,
 				phase: "skillopt.optimizer-model",
-				tags: runBudget.runTags
+				actor: name,
+				tags: { ...runBudget.attemptTags },
+				initialUsage: {
+					requests: priorOptimizerUsage.totalCalls,
+					...priorOptimizerUsage.costProvenance.kind === "uncaptured" ? {} : { costUsd: priorOptimizerUsage.totalCostUsd }
+				},
+				...signal ? { signal } : {}
 			});
-			const optimizerCost = costFromLedgerSummary(optimizerUsage);
-			modelProxy.assertExecutionComplete();
-			assertExternalOptimizerCompletionCount(result.tokenUsage, modelProxy.requestAttempts(), modelProxy.successfulCompletions(), name, "SkillOpt");
-			const tokenUsage = optimizationTokenUsageFromSummary(optimizerUsage, optimizerReceipts);
-			const runtime = observedExternalOptimizerRuntime(runtimeIdentity);
-			const combinedCost = combineComparisonCosts([{
-				label: "evaluation",
-				cost: evaluationCost
-			}, {
-				label: "optimizer model",
-				cost: optimizerCost
-			}]);
-			const searchHistory = config.searchLedger ? await recordSkillOptSearch({
-				name,
-				path: config.searchLedger.path ?? `${runDir}/search-ledger.jsonl`,
-				searchId: runId,
-				identity: config.searchLedger.identity,
-				storage,
-				seed: input.seed,
-				baselineSurface: input.baselineSurface,
-				trainScenarios: input.trainScenarios,
-				selectionScenarios: input.selectionScenarios,
-				evaluationLimit: config.maxEvaluations,
-				observations: readExternalOptimizerObservationArtifact({
-					summary: observationLog.summary(),
-					storage
-				}),
-				selected: result.bestCandidate,
-				generationAccounting: {
-					tokens: optimizerUsage.usageComplete ? {
-						status: "known",
-						inputTokens: optimizerUsage.inputTokens,
-						outputTokens: optimizerUsage.outputTokens,
-						cachedTokens: optimizerUsage.cachedTokens
-					} : {
-						status: "unknown",
-						reason: "an optimizer call reported no token usage"
-					},
-					cost: optimizerCost.accountingComplete ? {
-						status: "known",
-						usd: optimizerCost.totalCostUsd,
-						source: "provider"
-					} : {
-						status: "unknown",
-						knownLowerBoundUsd: optimizerCost.totalCostUsd,
-						reason: optimizerCost.incompleteReasons.join("; ") || "optimizer spend incomplete"
-					}
-				}
-			}) : void 0;
+			activeModelProxy = modelProxy;
+			const outputDir = `${runDir}/external`;
+			await mkdir(outputDir, { recursive: true });
 			return {
-				winnerSurface: result.bestCandidate,
-				...searchHistory ? { searchHistory } : {},
-				cost: combinedCost,
-				durationMs: Date.now() - started,
-				provenance: {
-					...runtime,
-					optimizerModel: config.optimizer.model,
-					optimizerCallRef: config.optimizer.callRef,
-					compatibleRunId,
-					runId,
-					resumed: result.resumed,
-					evaluationCount: runBudget.acceptedEvaluations(),
-					artifactDir: outputDir,
-					...tokenUsage ? { tokenUsage } : {},
-					observations: observationLog.summary(),
-					modelExecutions: executionLog.summary()
-				}
+				result: await runExternalOptimizerProcess({
+					label: "SkillOpt bridge",
+					tempPrefix: "agent-eval-skillopt-",
+					module: "agent_eval_rpc.skillopt_bridge",
+					input: {
+						attemptId: context.attemptId,
+						compatibleRunId: context.compatibleRunId,
+						runId: context.runId,
+						runtimeIdentity: context.runtimeIdentity,
+						resume: context.resume,
+						evaluationId: config.evaluationId,
+						seed: input.seed,
+						callbackUrl: callback.url,
+						callbackToken: callback.token,
+						objective: config.objective,
+						...config.background ? { background: config.background } : {},
+						trainer: config.trainer,
+						optimizerModel: config.optimizer.model,
+						modelBudget: config.optimizer.budget,
+						seedCandidate: input.baselineSurface,
+						trainSet: context.trainSet,
+						selectionSet: context.selectionSet,
+						maxEvaluations: config.maxEvaluations,
+						hardScoreThreshold: config.hardScoreThreshold ?? 1,
+						maxCandidateChars: context.maxCandidateChars,
+						maxEvidenceChars: context.maxEvidenceChars,
+						outputDir
+					},
+					runner: {
+						...context.bridgeRunner,
+						env: {
+							...removeCredentialEnvironment(runnerEnv),
+							...skillOptModelEnvironment(config, modelProxy)
+						}
+					},
+					timeoutMs: config.timeoutMs ?? 36e5,
+					...signal ? { signal } : {}
+				}),
+				outputDir,
+				modelProxy
 			};
+		},
+		cleanup: closeResources
+	});
+}
+/** Point every OpenAI-compatible client the bridge uses at the metered model proxy. */
+function skillOptModelEnvironment(config, modelProxy) {
+	const maxTokens = String(config.optimizer.budget.maxOutputTokensPerRequest);
+	return {
+		OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
+		OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
+		OPTIMIZER_OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
+		OPTIMIZER_OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
+		TARGET_OPENAI_COMPATIBLE_BASE_URL: modelProxy.baseUrl,
+		TARGET_OPENAI_COMPATIBLE_API_KEY: modelProxy.apiKey,
+		OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
+		OPENAI_COMPATIBLE_MAX_TOKENS: maxTokens,
+		OPTIMIZER_OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
+		OPTIMIZER_OPENAI_COMPATIBLE_MAX_TOKENS: maxTokens,
+		TARGET_OPENAI_COMPATIBLE_MODEL: config.optimizer.model,
+		TARGET_OPENAI_COMPATIBLE_MAX_TOKENS: maxTokens
+	};
+}
+/** Validate the bridge output against the run, total its spend, and build the method result. */
+async function finishSkillOptRun(context, result, outputDir, modelProxy) {
+	const { config, input, name, runBudget, callback, observationLog, executionLog } = context;
+	const { runtimeIdentity, compatibleRunId, runId } = context;
+	const costLedger = input.costLedger;
+	assertSkillOptBridgeOutput(result, name, context.maxCandidateChars, config.maxEvaluations);
+	assertExternalOptimizerRunBinding({
+		label: name,
+		runtime: runtimeIdentity,
+		returnedSource: result.upstream,
+		compatibleRunId,
+		runId,
+		returnedRunId: result.runId,
+		resume: context.resume,
+		resumed: result.resumed
+	});
+	if (callback.evaluations() !== result.totalEvaluations) throw new Error(`${name}: SkillOpt reported ${result.totalEvaluations} evaluations but the callback received ${callback.evaluations()}`);
+	const evaluationCost = costFromLedgerSummary(costLedger.summary({
+		phase: "skillopt.external-evaluation",
+		tags: runBudget.runTags
+	}));
+	const optimizerUsage = costLedger.summary({
+		phase: "skillopt.optimizer-model",
+		tags: runBudget.runTags
+	});
+	const optimizerReceipts = costLedger.list({
+		phase: "skillopt.optimizer-model",
+		tags: runBudget.runTags
+	});
+	const optimizerCost = costFromLedgerSummary(optimizerUsage);
+	modelProxy.assertExecutionComplete();
+	assertExternalOptimizerCompletionCount(result.tokenUsage, modelProxy.requestAttempts(), modelProxy.successfulCompletions(), name, "SkillOpt");
+	const tokenUsage = optimizationTokenUsageFromSummary(optimizerUsage, optimizerReceipts);
+	const runtime = observedExternalOptimizerRuntime(runtimeIdentity);
+	const combinedCost = combineComparisonCosts([{
+		label: "evaluation",
+		cost: evaluationCost
+	}, {
+		label: "optimizer model",
+		cost: optimizerCost
+	}]);
+	const searchHistory = config.searchLedger ? await recordSkillOptSearch({
+		name,
+		path: config.searchLedger.path ?? `${context.runDir}/search-ledger.jsonl`,
+		searchId: runId,
+		identity: config.searchLedger.identity,
+		storage: context.storage,
+		seed: input.seed,
+		baselineSurface: input.baselineSurface,
+		trainScenarios: input.trainScenarios,
+		selectionScenarios: input.selectionScenarios,
+		evaluationLimit: config.maxEvaluations,
+		observations: readExternalOptimizerObservationArtifact({
+			summary: observationLog.summary(),
+			storage: context.storage
+		}),
+		selected: result.bestCandidate,
+		generationAccounting: {
+			tokens: optimizerUsage.usageComplete ? {
+				status: "known",
+				inputTokens: optimizerUsage.inputTokens,
+				outputTokens: optimizerUsage.outputTokens,
+				cachedTokens: optimizerUsage.cachedTokens
+			} : {
+				status: "unknown",
+				reason: "an optimizer call reported no token usage"
+			},
+			cost: optimizerCost.accountingComplete ? {
+				status: "known",
+				usd: optimizerCost.totalCostUsd,
+				source: "provider"
+			} : {
+				status: "unknown",
+				knownLowerBoundUsd: optimizerCost.totalCostUsd,
+				reason: optimizerCost.incompleteReasons.join("; ") || "optimizer spend incomplete"
+			}
+		}
+	}) : void 0;
+	return {
+		winnerSurface: result.bestCandidate,
+		...searchHistory ? { searchHistory } : {},
+		cost: combinedCost,
+		durationMs: Date.now() - context.started,
+		provenance: {
+			...runtime,
+			optimizerModel: config.optimizer.model,
+			optimizerCallRef: config.optimizer.callRef,
+			compatibleRunId,
+			runId,
+			resumed: result.resumed,
+			evaluationCount: runBudget.acceptedEvaluations(),
+			artifactDir: outputDir,
+			...tokenUsage ? { tokenUsage } : {},
+			observations: observationLog.summary(),
+			modelExecutions: executionLog.summary()
 		}
 	};
 }
 //#endregion
 export { importExternalEvaluations as a, composeGate as c, readExternalOptimizerObservationArtifact as d, externalSurface as i, externalTextOptimizationMethod as l, compareOptimizationMethods as n, importGepaPopulation as o, gepaOptimizationMethod as r, heldOutGate as s, skillOptOptimizationMethod as t, decodeExternalTextCandidate as u };
 
-//# sourceMappingURL=skillopt-optimization-method-kyL94-ri.js.map
+//# sourceMappingURL=skillopt-optimization-method-5dlex7MJ.js.map