@tangle-network/agent-runtime 0.339.0 → 0.342.0

package/dist/{improve-BOXTLWJ3.js → improve-BZXt2qM0.js}

@@ -1,12 +1,12 @@
 import { a as syncDurableDirectory, i as publishExclusiveDurableFile } from "./durable-file-gNI9ILAn.js";
-import { Cr as runSettledCommand, Dr as terminateProcessTreeAndConfirm, Ei as detachedSnapshot, pt as createExecutor, vr as linkAbort, yr as runAbortable } from "./supervisor-DHrUJhEZ.js";
+import { Tr as terminateProcessTreeAndConfirm, _r as runAbortable, gr as linkAbort, mt as createExecutor, xi as detachedSnapshot, xr as runSettledCommand } from "./supervisor-DUWcecAd.js";
 import { i as ConfigError } from "./errors-DodWX-cb.js";
-import { F as collectAgentTurn, I as streamAgentTurn } from "./structural-rollout-DpLCXzaL.js";
-import { F as canonicalCandidateDigest$1, V as sha256Bytes$1, wt as armDeadlineTimer, z as immutableCandidateValue } from "./sandbox-profile-compat-BzVBFqrz.js";
+import { F as collectAgentTurn, I as streamAgentTurn } from "./structural-rollout-BD9IN7K_.js";
+import { B as sha256Bytes$1, Ct as armDeadlineTimer, P as canonicalCandidateDigest$1, R as immutableCandidateValue } from "./sandbox-profile-compat-FN2kab2-.js";
 import { a as concreteProfileModel, t as assertExecutableAgentProfile } from "./model-policy-CyCUwHed.js";
 import { t as sha256 } from "./content-digest-sBTLujlK.js";
-import { C as serializeRolloutPolicy, S as normalizeRolloutPolicy, w as structuralRolloutPolicyFromProfile, x as applyRolloutPolicyToProfile } from "./activation-CVSFxis9.js";
-import { a as reconcileInterruptedSearchCalls, b as improveSearchCost, c as searchExecutor, d as taggedLedger, i as isSearchEnvironmentFault, n as assertSearchLanes, s as searchCallTags, v as decideClosedSearch } from "./search-executor-zMumiak_.js";
+import { C as serializeRolloutPolicy, S as normalizeRolloutPolicy, w as structuralRolloutPolicyFromProfile, x as applyRolloutPolicyToProfile } from "./activation-CWPmt0Do.js";
+import { a as reconcileInterruptedSearchCalls, b as improveSearchCost, c as searchExecutor, d as taggedLedger, i as isSearchEnvironmentFault, n as assertSearchLanes, s as searchCallTags, v as decideClosedSearch } from "./search-executor-rbjdZ3OD.js";
 import { agentProfileEnvironmentSchema, agentProfileSchema, agentProfileTrainingSchema, agentTrainingDatasetIdentitySchema, agentTrainingParametersSchema, agentTrainingReceiptSchema, agentTrainingTaskKey, agentTrainingTaskSchema, applyAgentProfileDiff, canonicalAgentProfileDigest, canonicalCandidateBytes, diffAgentProfiles, sha256DigestSchema, snapshotAgentProfile, trainedModelIdForArtifact } from "@tangle-network/agent-interface";
 import { canonicalJson, makeProposalFinding } from "@tangle-network/agent-eval";
 import { redact } from "@tangle-network/agent-eval/traces";
@@ -50,6 +50,108 @@ function addRuntimeUsage(totals, event) {
 	if (isUsageAmount(event.estimatedCostUsd)) totals.estimatedCostUsd = (totals.estimatedCostUsd ?? 0) + event.estimatedCostUsd;
 }
 //#endregion
+//#region src/improvement/agentic-shot-evidence.ts
+async function emitShotReceipt(callback, receipt, execution, primaryError) {
+	try {
+		await callback?.(receipt, execution);
+	} catch (callbackError) {
+		if (primaryError !== null) throw new AggregateError([primaryError, callbackError], "agenticGenerator: author shot failed and its receipt could not be persisted");
+		throw callbackError;
+	}
+	if (primaryError !== null) throw primaryError;
+}
+async function emitShotDisposition(callback, receipt, disposition) {
+	await callback?.(receipt, disposition);
+}
+async function rethrowShotSetupError(callback, receipt, worktreePath, stage, cause) {
+	const error = cause instanceof Error ? cause : new Error(String(cause));
+	try {
+		await emitShotDisposition(callback, receipt, {
+			kind: "setup-error",
+			worktreePath,
+			stage,
+			error: {
+				name: error.name,
+				message: error.message
+			}
+		});
+	} catch (callbackError) {
+		throw new AggregateError([cause, callbackError], "agenticGenerator: shot processing failed and its worktree disposition could not be persisted");
+	}
+	throw cause;
+}
+function shotReceipt(input) {
+	const error = input.error ? {
+		name: input.error instanceof Error ? input.error.name : "Error",
+		message: input.error instanceof Error ? input.error.message : String(input.error)
+	} : null;
+	const result = input.result;
+	const costBasis = costBasisFor(input.costReceipt, result);
+	const costUsd = input.costReceipt?.costUsd ?? result?.usage.costUsd ?? result?.usage.estimatedCostUsd ?? null;
+	return {
+		generation: input.generation ?? null,
+		candidateIndex: input.candidateIndex ?? null,
+		shot: input.shot + 1,
+		maxShots: input.maxShots,
+		profileDigest: input.profileDigest,
+		harness: input.harness,
+		provider: input.provider,
+		model: input.model,
+		reasoningEffort: input.profile.model?.reasoningEffort ?? null,
+		promptSha256: `sha256:${sha256(input.prompt)}`,
+		startedAt: input.startedAt.toISOString(),
+		completedAt: input.completedAt.toISOString(),
+		durationMs: input.completedAt.getTime() - input.startedAt.getTime(),
+		status: result?.status ?? null,
+		usage: result ? { ...result.usage } : null,
+		transportAttempts: result?.transportAttempts ?? null,
+		costCallId: input.costCallId,
+		costBasis,
+		costUsd: costBasis === "unknown" ? null : costUsd,
+		costUsdKnown: costBasis === "provider-reported",
+		error
+	};
+}
+function costBasisFor(receipt, turn) {
+	if (receipt) {
+		if (receipt.costUnknown) return "unknown";
+		return receipt.actualCostUsd === void 0 ? "estimated-pricing" : "provider-reported";
+	}
+	if (turn?.usage.usdKnown !== false && turn?.usage.costUsd !== void 0) return "provider-reported";
+	return turn?.usage.estimatedCostUsd !== void 0 ? "estimated-pricing" : "unknown";
+}
+function shotFailure(result) {
+	if (result.status === "completed") return null;
+	if (result.status === "aborted") return /* @__PURE__ */ new Error("agenticGenerator: author shot was cancelled by the caller");
+	return /* @__PURE__ */ new Error(`agenticGenerator: author shot failed${result.error?.message ? `: ${result.error.message}` : ""}`);
+}
+function costReceiptFromTurn(result, model) {
+	const tokensKnown = result.usage.tokensKnown !== false;
+	const actualCostUsd = result.usage.usdKnown === false ? void 0 : result.usage.costUsd;
+	const cachedTokens = promptCacheReadTokens(result.usage);
+	return {
+		model,
+		inputTokens: tokensKnown ? Math.max(0, result.usage.input - (cachedTokens ?? 0)) : 0,
+		outputTokens: tokensKnown ? result.usage.output : 0,
+		...tokensKnown ? {} : { usageUnknown: true },
+		...cachedTokens !== void 0 ? { cachedTokens } : {},
+		...result.usage.reasoningTokens !== void 0 ? { reasoningTokens: result.usage.reasoningTokens } : {},
+		...actualCostUsd !== void 0 ? { actualCostUsd } : result.usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: result.usage.estimatedCostUsd } : { costUnknown: true }
+	};
+}
+function promptCacheReadTokens(usage) {
+	const cache = usage.promptCache;
+	if (!cache) return void 0;
+	for (const field of [
+		"readTokens",
+		"cachedInputTokens",
+		"cacheReadInputTokens"
+	]) {
+		const value = cache[field];
+		if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
+	}
+}
+//#endregion
 //#region src/improvement/worktree-tree.ts
 /**
 * The exact content of a candidate worktree, as a Git tree object.
@@ -192,229 +294,275 @@ function agenticGenerator(opts) {
 	const profile = detachedSnapshot(agentProfileSchema.parse(opts.profile), "agenticGenerator profile");
 	assertExecutableAgentProfile(profile, "agenticGenerator");
 	const harness = profile.harness;
-	const provider = profile.model.provider.trim();
-	const model = concreteProfileModel(profile);
-	const profileDigest = canonicalAgentProfileDigest(profile);
-	const dirty = opts.isDirty ?? worktreeDirty;
-	const verify = opts.verify;
+	const author = {
+		opts,
+		profile,
+		harness,
+		provider: profile.model.provider.trim(),
+		model: concreteProfileModel(profile),
+		profileDigest: canonicalAgentProfileDigest(profile),
+		dirty: opts.isDirty ?? worktreeDirty
+	};
 	return {
 		kind: `agentic:${harness}`,
 		proposesWithoutFindings: true,
-		async generate({ worktreePath, findings, maxShots, signal, generation, candidateIndex, costLedger, costPhase }) {
+		generate: (request) => generateCandidate(author, request)
+	};
+}
+async function generateCandidate(author, request) {
+	const { opts, harness, provider, model, profile, profileDigest } = author;
+	const { findings, maxShots, signal, generation, candidateIndex } = request;
+	signal.throwIfAborted();
+	const { basePrompt, factory } = prepareAuthoring(author, request);
+	const needsRawTraceEvidence = requiresRawTraceEvidence(findings);
+	const shots = Math.max(1, maxShots);
+	const state = {
+		attemptNote: "",
+		best: null,
+		scored: null,
+		lastReceipt: null
+	};
+	for (let shot = 0; shot < shots; shot++) {
+		signal.throwIfAborted();
+		if (state.best) state.best.onDisk = false;
+		const taskPrompt = state.attemptNote ? `${basePrompt}\n\n${state.attemptNote}` : basePrompt;
+		const startedAt = /* @__PURE__ */ new Date();
+		const ran = await runAuthorShot(author, request, factory, taskPrompt, shot);
+		const execution = ran.turn ? detachedSnapshot(ran.turn, "agenticGenerator shot execution") : null;
+		const receipt = shotReceipt({
+			generation,
+			candidateIndex,
+			shot,
+			maxShots: shots,
+			harness,
+			provider,
+			model,
+			profile,
+			profileDigest,
+			prompt: taskPrompt,
+			startedAt,
+			completedAt: /* @__PURE__ */ new Date(),
+			result: execution,
+			costCallId: ran.costCallId,
+			costReceipt: ran.costReceipt,
+			error: ran.shotError
+		});
+		state.lastReceipt = receipt;
+		await emitShotReceipt(opts.onShotCompleted, receipt, execution, ran.shotError);
+		signal.throwIfAborted();
+		if (!execution) throw new Error("agenticGenerator: author shot completed without a Runtime turn");
+		const step = await settleShot(author, request, state, receipt, {
+			shot,
+			shots,
+			needsRawTraceEvidence
+		});
+		if ("candidate" in step) return step.candidate;
+		state.attemptNote = step.note;
+	}
+	if (state.best !== null) {
+		if (!state.lastReceipt) throw new Error("agenticGenerator: a tree was banked without a shot receipt");
+		return await shipBankedTree(author, request, state.lastReceipt, state.best);
+	}
+	return {
+		applied: false,
+		summary: ""
+	};
+}
+/** Check the request and build the author's prompt and executor, before any shot spends. */
+function prepareAuthoring(author, request) {
+	const { opts } = author;
+	const { worktreePath, findings, costLedger } = request;
+	if (opts.maximumCharge && !costLedger) throw new Error("agenticGenerator: maximumCharge requires the run-wide CostLedger supplied by agent-eval");
+	const basePrompt = opts.buildPrompt({ findings });
+	if (typeof basePrompt !== "string" || basePrompt.trim().length === 0) throw new Error("agenticGenerator: buildPrompt must return a non-empty string");
+	const executorConfig = opts.executorForWorktree(worktreePath);
+	if (executorConfig.backend === "bridge" && !samePath(executorConfig.cwd, worktreePath)) throw new Error("agenticGenerator: bridge executor cwd must equal the candidate worktree path");
+	if (executorConfig.backend === "cli-in-place" && !samePath(executorConfig.workspacePath, worktreePath)) throw new Error("agenticGenerator: cli-in-place executor workspacePath must equal the candidate worktree path");
+	return {
+		basePrompt,
+		factory: createExecutor(executorConfig)
+	};
+}
+/** Run one author shot through the run-wide ledger when there is one. A failure is returned, not thrown. */
+async function runAuthorShot(author, request, factory, taskPrompt, shot) {
+	const { opts, profile, harness, model } = author;
+	const { signal, generation, candidateIndex, costLedger, costPhase } = request;
+	let turn = null;
+	let costReceipt = null;
+	let costCallId = null;
+	let shotError = null;
+	try {
+		const execute = async (executionSignal, callId) => {
+			turn = await collectAgentTurn(streamAgentTurn({
+				kind: "executor",
+				profile,
+				factory
+			}, { prompt: taskPrompt }, {
+				signal: executionSignal,
+				...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+				...callId ? { callId } : {}
+			}));
+			const failure = shotFailure(turn);
+			if (failure) throw failure;
+			return turn;
+		};
+		if (costLedger) {
+			const paid = await costLedger.runPaidCall({
+				channel: "driver",
+				phase: costPhase ?? "search.proposal",
+				actor: `agentic-generator:${harness}`,
+				model,
+				tags: {
+					generation: String(generation ?? -1),
+					candidateIndex: String(candidateIndex ?? -1),
+					shot: String(shot + 1)
+				},
+				signal,
+				...opts.maximumCharge ? { maximumCharge: opts.maximumCharge } : {},
+				execute: (executionSignal, callId) => execute(executionSignal, callId),
+				receipt: (result) => costReceiptFromTurn(result, model),
+				receiptFromError: () => turn ? costReceiptFromTurn(turn, model) : void 0
+			});
+			costCallId = paid.callId ?? null;
+			costReceipt = paid.receipt ?? null;
+			if (!paid.succeeded) throw paid.error;
+			turn = paid.value;
+		} else turn = await execute(signal);
+	} catch (cause) {
+		shotError = cause instanceof Error ? cause : new Error(String(cause));
+	}
+	return {
+		turn,
+		costReceipt,
+		costCallId,
+		shotError
+	};
+}
+/** Decide what a completed shot's worktree means: ship it, or the note the next shot starts from. */
+async function settleShot(author, request, state, receipt, position) {
+	const { opts, dirty } = author;
+	const { worktreePath, findings, signal } = request;
+	let worktreeChanged;
+	try {
+		worktreeChanged = dirty(worktreePath);
+	} catch (cause) {
+		signal.throwIfAborted();
+		return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "worktree-inspection", cause);
+	}
+	if (!worktreeChanged) {
+		signal.throwIfAborted();
+		await emitShotDisposition(opts.onShotDisposition, receipt, {
+			kind: "clean",
+			worktreePath
+		});
+		signal.throwIfAborted();
+		return { note: EMPTY_TREE_NOTE };
+	}
+	if (position.needsRawTraceEvidence) {
+		let problem;
+		try {
+			problem = rawTraceEvidenceProblem(worktreePath, findings);
+		} catch (cause) {
 			signal.throwIfAborted();
-			if (opts.maximumCharge && !costLedger) throw new Error("agenticGenerator: maximumCharge requires the run-wide CostLedger supplied by agent-eval");
-			const basePrompt = opts.buildPrompt({ findings });
-			if (typeof basePrompt !== "string" || basePrompt.trim().length === 0) throw new Error("agenticGenerator: buildPrompt must return a non-empty string");
-			const executorConfig = opts.executorForWorktree(worktreePath);
-			if (executorConfig.backend === "bridge" && !samePath(executorConfig.cwd, worktreePath)) throw new Error("agenticGenerator: bridge executor cwd must equal the candidate worktree path");
-			if (executorConfig.backend === "cli-in-place" && !samePath(executorConfig.workspacePath, worktreePath)) throw new Error("agenticGenerator: cli-in-place executor workspacePath must equal the candidate worktree path");
-			const factory = createExecutor(executorConfig);
-			const needsRawTraceEvidence = requiresRawTraceEvidence(findings);
-			const shots = Math.max(1, maxShots);
-			let attemptNote = "";
-			let best = null;
-			let scored = null;
-			let lastReceipt = null;
-			/** Ship the best tree this candidate produced, restoring it when a later
-			*  shot wrote over it. */
-			const shipBankedTree = async (receipt, banked) => {
-				const restoredFromShot = banked.onDisk ? null : banked.shot;
-				if (!banked.onDisk) {
-					if (banked.tree === null) throw new Error(`agenticGenerator: shot ${banked.shot} produced the best tree but it was never snapshotted`);
-					restoreWorktreeTree(worktreePath, banked.tree);
-					banked.onDisk = true;
-				}
-				signal.throwIfAborted();
-				await emitShotDisposition(opts.onShotDisposition, receipt, {
-					kind: "accepted",
-					worktreePath,
-					verified: true,
-					restoredFromShot
-				});
-				signal.throwIfAborted();
-				return acceptedCandidate(findings);
-			};
-			for (let shot = 0; shot < shots; shot++) {
-				signal.throwIfAborted();
-				if (best) best.onDisk = false;
-				const taskPrompt = attemptNote ? `${basePrompt}\n\n${attemptNote}` : basePrompt;
-				const startedAt = /* @__PURE__ */ new Date();
-				let turn = null;
-				let costReceipt = null;
-				let costCallId = null;
-				let shotError = null;
-				try {
-					const execute = async (executionSignal, callId) => {
-						turn = await collectAgentTurn(streamAgentTurn({
-							kind: "executor",
-							profile,
-							factory
-						}, { prompt: taskPrompt }, {
-							signal: executionSignal,
-							...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
-							...callId ? { callId } : {}
-						}));
-						const failure = shotFailure(turn);
-						if (failure) throw failure;
-						return turn;
-					};
-					if (costLedger) {
-						const paid = await costLedger.runPaidCall({
-							channel: "driver",
-							phase: costPhase ?? "search.proposal",
-							actor: `agentic-generator:${harness}`,
-							model,
-							tags: {
-								generation: String(generation ?? -1),
-								candidateIndex: String(candidateIndex ?? -1),
-								shot: String(shot + 1)
-							},
-							signal,
-							...opts.maximumCharge ? { maximumCharge: opts.maximumCharge } : {},
-							execute: (executionSignal, callId) => execute(executionSignal, callId),
-							receipt: (result) => costReceiptFromTurn(result, model),
-							receiptFromError: () => turn ? costReceiptFromTurn(turn, model) : void 0
-						});
-						costCallId = paid.callId ?? null;
-						costReceipt = paid.receipt ?? null;
-						if (!paid.succeeded) throw paid.error;
-						turn = paid.value;
-					} else turn = await execute(signal);
-				} catch (cause) {
-					shotError = cause instanceof Error ? cause : new Error(String(cause));
-				}
-				const execution = turn ? detachedSnapshot(turn, "agenticGenerator shot execution") : null;
-				const receipt = shotReceipt({
-					generation,
-					candidateIndex,
-					shot,
-					maxShots: shots,
-					harness,
-					provider,
-					model,
-					profile,
-					profileDigest,
-					prompt: taskPrompt,
-					startedAt,
-					completedAt: /* @__PURE__ */ new Date(),
-					result: execution,
-					costCallId,
-					costReceipt,
-					error: shotError
-				});
-				lastReceipt = receipt;
-				await emitShotReceipt(opts.onShotCompleted, receipt, execution, shotError);
-				signal.throwIfAborted();
-				if (!execution) throw new Error("agenticGenerator: author shot completed without a Runtime turn");
-				let worktreeChanged;
-				try {
-					worktreeChanged = dirty(worktreePath);
-				} catch (cause) {
-					signal.throwIfAborted();
-					return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "worktree-inspection", cause);
-				}
-				if (!worktreeChanged) {
-					signal.throwIfAborted();
-					await emitShotDisposition(opts.onShotDisposition, receipt, {
-						kind: "clean",
-						worktreePath
-					});
-					signal.throwIfAborted();
-					attemptNote = EMPTY_TREE_NOTE;
-					continue;
-				}
-				if (needsRawTraceEvidence) {
-					let problem;
-					try {
-						problem = rawTraceEvidenceProblem(worktreePath, findings);
-					} catch (cause) {
-						signal.throwIfAborted();
-						return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "raw-trace-evidence", cause);
-					}
-					if (problem) {
-						signal.throwIfAborted();
-						await emitShotDisposition(opts.onShotDisposition, receipt, {
-							kind: "rejected",
-							worktreePath,
-							stage: "raw-trace-evidence",
-							feedback: problem
-						});
-						signal.throwIfAborted();
-						attemptNote = problem;
-						continue;
-					}
-				}
-				if (!verify) {
-					signal.throwIfAborted();
-					await emitShotDisposition(opts.onShotDisposition, receipt, {
-						kind: "accepted",
-						worktreePath,
-						verified: false,
-						restoredFromShot: null
-					});
-					signal.throwIfAborted();
-					return acceptedCandidate(findings);
-				}
-				let result;
-				try {
-					signal.throwIfAborted();
-					result = await verify(worktreePath, signal);
-					signal.throwIfAborted();
-				} catch (cause) {
-					signal.throwIfAborted();
-					return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "verification", cause);
-				}
-				if (result.ok) {
-					const score = admittedScore(result, scored, shot);
-					scored = score !== null;
-					const previousBest = best;
-					let banked;
-					if (previousBest === null || (score ?? 0) >= (previousBest.score ?? 0)) banked = {
-						shot: shot + 1,
-						score,
-						tree: null,
-						onDisk: true
-					};
-					else banked = previousBest;
-					const becomesBest = banked !== previousBest;
-					best = banked;
-					if (result.keepGoing !== true) {
-						signal.throwIfAborted();
-						return await shipBankedTree(receipt, banked);
-					}
-					if (becomesBest && shot < shots - 1) banked.tree = snapshotWorktreeTree(worktreePath);
-					signal.throwIfAborted();
-					await emitShotDisposition(opts.onShotDisposition, receipt, {
-						kind: "kept",
-						worktreePath,
-						score,
-						best: becomesBest,
-						feedback: result.feedback ?? null
-					});
-					signal.throwIfAborted();
-					attemptNote = keptNote(result.feedback);
-					continue;
-				}
-				signal.throwIfAborted();
-				await emitShotDisposition(opts.onShotDisposition, receipt, {
-					kind: "rejected",
-					worktreePath,
-					stage: "verification",
-					feedback: result.feedback ?? null
-				});
-				signal.throwIfAborted();
-				attemptNote = failureNote(result.feedback);
-			}
-			if (best !== null) {
-				if (!lastReceipt) throw new Error("agenticGenerator: a tree was banked without a shot receipt");
-				return await shipBankedTree(lastReceipt, best);
-			}
-			return {
-				applied: false,
-				summary: ""
-			};
+			return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "raw-trace-evidence", cause);
 		}
-	};
+		if (problem) {
+			signal.throwIfAborted();
+			await emitShotDisposition(opts.onShotDisposition, receipt, {
+				kind: "rejected",
+				worktreePath,
+				stage: "raw-trace-evidence",
+				feedback: problem
+			});
+			signal.throwIfAborted();
+			return { note: problem };
+		}
+	}
+	if (!opts.verify) {
+		signal.throwIfAborted();
+		await emitShotDisposition(opts.onShotDisposition, receipt, {
+			kind: "accepted",
+			worktreePath,
+			verified: false,
+			restoredFromShot: null
+		});
+		signal.throwIfAborted();
+		return { candidate: acceptedCandidate(findings) };
+	}
+	return settleVerifiedShot(author, request, state, receipt, position, opts.verify);
+}
+/** Run the verifier on a dirty tree, then ship, bank or reject it. */
+async function settleVerifiedShot(author, request, state, receipt, { shot, shots }, verify) {
+	const { opts } = author;
+	const { worktreePath, signal } = request;
+	let result;
+	try {
+		signal.throwIfAborted();
+		result = await verify(worktreePath, signal);
+		signal.throwIfAborted();
+	} catch (cause) {
+		signal.throwIfAborted();
+		return rethrowShotSetupError(opts.onShotDisposition, receipt, worktreePath, "verification", cause);
+	}
+	if (result.ok) {
+		const score = admittedScore(result, state.scored, shot);
+		state.scored = score !== null;
+		const previousBest = state.best;
+		let banked;
+		if (previousBest === null || (score ?? 0) >= (previousBest.score ?? 0)) banked = {
+			shot: shot + 1,
+			score,
+			tree: null,
+			onDisk: true
+		};
+		else banked = previousBest;
+		const becomesBest = banked !== previousBest;
+		state.best = banked;
+		if (result.keepGoing !== true) {
+			signal.throwIfAborted();
+			return { candidate: await shipBankedTree(author, request, receipt, banked) };
+		}
+		if (becomesBest && shot < shots - 1) banked.tree = snapshotWorktreeTree(worktreePath);
+		signal.throwIfAborted();
+		await emitShotDisposition(opts.onShotDisposition, receipt, {
+			kind: "kept",
+			worktreePath,
+			score,
+			best: becomesBest,
+			feedback: result.feedback ?? null
+		});
+		signal.throwIfAborted();
+		return { note: keptNote(result.feedback) };
+	}
+	signal.throwIfAborted();
+	await emitShotDisposition(opts.onShotDisposition, receipt, {
+		kind: "rejected",
+		worktreePath,
+		stage: "verification",
+		feedback: result.feedback ?? null
+	});
+	signal.throwIfAborted();
+	return { note: failureNote(result.feedback) };
+}
+/** Ship the best tree this candidate produced, restoring it when a later
+*  shot wrote over it. */
+async function shipBankedTree(author, request, receipt, banked) {
+	const { worktreePath, findings, signal } = request;
+	const restoredFromShot = banked.onDisk ? null : banked.shot;
+	if (!banked.onDisk) {
+		if (banked.tree === null) throw new Error(`agenticGenerator: shot ${banked.shot} produced the best tree but it was never snapshotted`);
+		restoreWorktreeTree(worktreePath, banked.tree);
+		banked.onDisk = true;
+	}
+	signal.throwIfAborted();
+	await emitShotDisposition(author.opts.onShotDisposition, receipt, {
+		kind: "accepted",
+		worktreePath,
+		verified: true,
+		restoredFromShot
+	});
+	signal.throwIfAborted();
+	return acceptedCandidate(findings);
 }
 /** The rank a passing tree carries, refusing a set of trees that cannot be ordered. */
 function admittedScore(result, scored, shot) {
@@ -424,129 +572,29 @@ function admittedScore(result, scored, shot) {
 	if (typeof result.score !== "number" || !Number.isFinite(result.score)) throw new Error(`agenticGenerator: verify returned a non-finite score (${String(result.score)}) for shot ${shot + 1}`);
 	return result.score;
 }
-async function emitShotReceipt(callback, receipt, execution, primaryError) {
-	try {
-		await callback?.(receipt, execution);
-	} catch (callbackError) {
-		if (primaryError !== null) throw new AggregateError([primaryError, callbackError], "agenticGenerator: author shot failed and its receipt could not be persisted");
-		throw callbackError;
-	}
-	if (primaryError !== null) throw primaryError;
+const EMPTY_TREE_NOTE = "NOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.";
+/** Next-shot feedback when the worktree is dirty but failed verification. The
+*  edits persist on disk, so the harness resumes atop them — tell it to fix in
+*  place, not start over. Verifier detail is truncated to keep the prompt bounded. */
+function failureNote(feedback) {
+	const detail = feedback?.trim();
+	return [
+		"NOTE: your edits are in the working tree but verification FAILED.",
+		"Fix the problem in place — build on your existing edits, do not revert them.",
+		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
+	].join("\n");
 }
-async function emitShotDisposition(callback, receipt, disposition) {
-	await callback?.(receipt, disposition);
-}
-async function rethrowShotSetupError(callback, receipt, worktreePath, stage, cause) {
-	const error = cause instanceof Error ? cause : new Error(String(cause));
-	try {
-		await emitShotDisposition(callback, receipt, {
-			kind: "setup-error",
-			worktreePath,
-			stage,
-			error: {
-				name: error.name,
-				message: error.message
-			}
-		});
-	} catch (callbackError) {
-		throw new AggregateError([cause, callbackError], "agenticGenerator: shot processing failed and its worktree disposition could not be persisted");
-	}
-	throw cause;
-}
-function shotReceipt(input) {
-	const error = input.error ? {
-		name: input.error instanceof Error ? input.error.name : "Error",
-		message: input.error instanceof Error ? input.error.message : String(input.error)
-	} : null;
-	const result = input.result;
-	const costBasis = costBasisFor(input.costReceipt, result);
-	const costUsd = input.costReceipt?.costUsd ?? result?.usage.costUsd ?? result?.usage.estimatedCostUsd ?? null;
-	return {
-		generation: input.generation ?? null,
-		candidateIndex: input.candidateIndex ?? null,
-		shot: input.shot + 1,
-		maxShots: input.maxShots,
-		profileDigest: input.profileDigest,
-		harness: input.harness,
-		provider: input.provider,
-		model: input.model,
-		reasoningEffort: input.profile.model?.reasoningEffort ?? null,
-		promptSha256: `sha256:${sha256(input.prompt)}`,
-		startedAt: input.startedAt.toISOString(),
-		completedAt: input.completedAt.toISOString(),
-		durationMs: input.completedAt.getTime() - input.startedAt.getTime(),
-		status: result?.status ?? null,
-		usage: result ? { ...result.usage } : null,
-		transportAttempts: result?.transportAttempts ?? null,
-		costCallId: input.costCallId,
-		costBasis,
-		costUsd: costBasis === "unknown" ? null : costUsd,
-		costUsdKnown: costBasis === "provider-reported",
-		error
-	};
-}
-function costBasisFor(receipt, turn) {
-	if (receipt) {
-		if (receipt.costUnknown) return "unknown";
-		return receipt.actualCostUsd === void 0 ? "estimated-pricing" : "provider-reported";
-	}
-	if (turn?.usage.usdKnown !== false && turn?.usage.costUsd !== void 0) return "provider-reported";
-	return turn?.usage.estimatedCostUsd !== void 0 ? "estimated-pricing" : "unknown";
-}
-function shotFailure(result) {
-	if (result.status === "completed") return null;
-	if (result.status === "aborted") return /* @__PURE__ */ new Error("agenticGenerator: author shot was cancelled by the caller");
-	return /* @__PURE__ */ new Error(`agenticGenerator: author shot failed${result.error?.message ? `: ${result.error.message}` : ""}`);
-}
-function costReceiptFromTurn(result, model) {
-	const tokensKnown = result.usage.tokensKnown !== false;
-	const actualCostUsd = result.usage.usdKnown === false ? void 0 : result.usage.costUsd;
-	const cachedTokens = promptCacheReadTokens(result.usage);
-	return {
-		model,
-		inputTokens: tokensKnown ? Math.max(0, result.usage.input - (cachedTokens ?? 0)) : 0,
-		outputTokens: tokensKnown ? result.usage.output : 0,
-		...tokensKnown ? {} : { usageUnknown: true },
-		...cachedTokens !== void 0 ? { cachedTokens } : {},
-		...result.usage.reasoningTokens !== void 0 ? { reasoningTokens: result.usage.reasoningTokens } : {},
-		...actualCostUsd !== void 0 ? { actualCostUsd } : result.usage.estimatedCostUsd !== void 0 ? { estimatedCostUsd: result.usage.estimatedCostUsd } : { costUnknown: true }
-	};
-}
-function promptCacheReadTokens(usage) {
-	const cache = usage.promptCache;
-	if (!cache) return void 0;
-	for (const field of [
-		"readTokens",
-		"cachedInputTokens",
-		"cacheReadInputTokens"
-	]) {
-		const value = cache[field];
-		if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
-	}
-}
-const EMPTY_TREE_NOTE = "NOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.";
-/** Next-shot feedback when the worktree is dirty but failed verification. The
-*  edits persist on disk, so the harness resumes atop them — tell it to fix in
-*  place, not start over. Verifier detail is truncated to keep the prompt bounded. */
-function failureNote(feedback) {
-	const detail = feedback?.trim();
-	return [
-		"NOTE: your edits are in the working tree but verification FAILED.",
-		"Fix the problem in place — build on your existing edits, do not revert them.",
-		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
-	].join("\n");
-}
-/** Next-shot feedback when the worktree PASSED and the verifier asked for
-*  another shot. The passing tree is banked, so the author is told to improve
-*  it rather than protect it — a worse tree cannot cost it the candidate. */
-function keptNote(feedback) {
-	const detail = feedback?.trim();
-	return [
-		"NOTE: your edits are in the working tree and verification PASSED.",
-		"Shots remain in this budget — keep improving the change in place, do not revert it.",
-		"The best version you produce is the one that ships.",
-		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
-	].join("\n");
+/** Next-shot feedback when the worktree PASSED and the verifier asked for
+*  another shot. The passing tree is banked, so the author is told to improve
+*  it rather than protect it — a worse tree cannot cost it the candidate. */
+function keptNote(feedback) {
+	const detail = feedback?.trim();
+	return [
+		"NOTE: your edits are in the working tree and verification PASSED.",
+		"Shots remain in this budget — keep improving the change in place, do not revert it.",
+		"The best version you produce is the one that ships.",
+		detail ? `Verifier output:\n${truncate$1(detail, 4e3)}` : "No verifier detail was captured."
+	].join("\n");
 }
 function rawTraceEvidenceProblem(worktreePath, findings) {
 	if (worktreeChangedPaths(worktreePath).filter((path) => path !== RAW_TRACE_DIAGNOSIS_PATH).length === 0) return [`NOTE: raw-trace mode requires a real code/config edit in addition to ${RAW_TRACE_DIAGNOSIS_PATH}.`, "Your previous attempt only changed the diagnosis artifact. Inspect the cited traces and make the causal code change."].join("\n");
@@ -1974,6 +2022,121 @@ async function runMethodImprovement(profile, opts) {
 	};
 }
 //#endregion
+//#region src/improvement/search-session.ts
+/** A refusal as the ledger stores it: redacted with the share profile. */
+function searchRefusalText(error) {
+	return redact(error instanceof Error ? error.message : String(error), { profile: "share" }).value;
+}
+/** The node a candidate surface becomes: materialized, or refused with the reason. */
+function profileNodeOf(prepared, candidateSurface) {
+	const surface = immutableCandidateValue(candidateSurface);
+	try {
+		return {
+			surface,
+			profile: prepared.materializeCandidate(surface),
+			refusal: null
+		};
+	} catch (error) {
+		return {
+			surface,
+			profile: null,
+			refusal: searchRefusalText(error)
+		};
+	}
+}
+/**
+* The codec that also records each node's profile by node id. Placement reads a node's profile
+* to skip the lanes that refuse it, so every node the ledger holds, and every node this process
+* registers, is known before its cells are placed.
+*/
+function registeringProfileCodec(prepared, searchId, profiles) {
+	const profiled = profileCodec(prepared);
+	return {
+		node(recorder, node) {
+			const registered = profiled.node(recorder, node);
+			profiles.set(searchNodeId(searchId, registered.artifactDigest), node.profile);
+			return registered;
+		},
+		diff: profiled.diff,
+		load(recorder, node) {
+			const loaded = profiled.load(recorder, node);
+			profiles.set(node.nodeId, loaded.profile);
+			return loaded;
+		}
+	};
+}
+/** Profiles as search artifacts: nodes by profile digest, edges by profile diffs. */
+function profileCodec(prepared) {
+	const surfaceId = prepared.surface;
+	return {
+		node(recorder, node) {
+			if (node.profile) {
+				const artifact = recorder.blob("agent-profile", {
+					kind: "agent-profile",
+					profile: node.profile
+				});
+				return {
+					artifactDigest: canonicalAgentProfileDigest(node.profile),
+					artifact,
+					surfaces: [{
+						surfaceId,
+						kind: "agent-profile",
+						artifact
+					}]
+				};
+			}
+			const artifact = recorder.blob("surface", {
+				kind: "unmaterialized-surface",
+				surface: node.surface,
+				refusal: node.refusal
+			});
+			return {
+				artifactDigest: canonicalCandidateDigest$1({
+					kind: "unmaterialized-surface",
+					surface: node.surface
+				}),
+				artifact,
+				surfaces: [{
+					surfaceId,
+					kind: "agent-profile",
+					artifact
+				}]
+			};
+		},
+		diff(recorder, parent, child) {
+			if (!parent.profile || !child.profile) return { unknown: "a surface that does not materialize has no profile to diff" };
+			const diffs = diffAgentProfiles(parent.profile, child.profile);
+			const to = canonicalAgentProfileDigest(child.profile);
+			if (canonicalAgentProfileDigest(diffs.reduce(applyAgentProfileDiff, parent.profile)) !== to) return { unknown: "the Interface profile diffs do not reproduce the child profile" };
+			return recorder.blob("diff", {
+				kind: "agent-profile-diff",
+				from: canonicalAgentProfileDigest(parent.profile),
+				to,
+				diffs
+			});
+		},
+		load(recorder, node) {
+			const stored = recorder.readBlob(node.artifact);
+			if (stored.kind === "agent-profile") {
+				const parsed = agentProfileSchema.safeParse(stored.profile);
+				if (!parsed.success) throw new Error(`improve(): node ${node.nodeId} holds an invalid AgentProfile`);
+				const loaded = immutableCandidateValue(parsed.data);
+				return {
+					surface: prepared.surfaceOf(loaded),
+					profile: loaded,
+					refusal: null
+				};
+			}
+			if (stored.kind === "unmaterialized-surface" && stored.surface !== void 0) return {
+				surface: stored.surface,
+				profile: null,
+				refusal: stored.refusal ?? null
+			};
+			throw new Error(`improve(): node ${node.nodeId} holds no profile search artifact`);
+		}
+	};
+}
+//#endregion
 //#region src/improvement/search-method.ts
 /** Build Runtime's native search for `improve(profile, { method })`. */
 function searchMethod(options) {
@@ -2025,14 +2188,12 @@ const SEARCH_METHOD_SOURCE = {
 };
 async function runSearchImprovement(profile, opts) {
 	const { method, claim: inputClaim, agent, executionRunId, recordCell, trainScenarios, selectionScenarios, testScenarios, judges: _judges, surface: _surface, executionRef: _executionRef, validateCandidate: _validateCandidate, findings: _findings, skills: _skills, profileComponents: _profileComponents, minimumLift: _minimumLift, subject: _subject, costCeiling, costLedger: inputCostLedger, seed = 42, signal, workerSlots, budgetPool, trace, ...campaignOptions } = opts;
-	if (!isImproveSearchMethod(method)) throw new ConfigError("improve(): a search needs method: searchMethod(...)");
-	const claim = defineEvaluationClaim(inputClaim);
-	if (claim.minimumEffect === void 0) throw new ConfigError("improve(): a search claim needs minimumEffect for its power check");
-	for (const [name, split] of [
-		["trainScenarios", trainScenarios],
-		["selectionScenarios", selectionScenarios],
-		["testScenarios", testScenarios]
-	]) if (!Array.isArray(split) || split.length === 0) throw new ConfigError(`improve(): a search needs at least one of ${name}`);
+	const splitScenarios = {
+		trainScenarios,
+		selectionScenarios,
+		testScenarios
+	};
+	const claim = assertSearchRequest(method, inputClaim, splitScenarios);
 	const { allocation, policy, lanes } = method;
 	const reps = allocation.reps;
 	const concurrency = lanes.reduce((total, lane) => total + lane.capacity, 0);
@@ -2059,121 +2220,34 @@ async function runSearchImprovement(profile, opts) {
 		runDir: searchDir,
 		costCeilingUsd: costCeiling
 	});
-	const unitOf = (scenario) => summarizeEvaluationUnits(claim, [scenario]).units[0].id;
-	const tasks = (scenarios) => scenarios.map((scenario) => ({
-		taskId: scenario.id,
-		unitId: unitOf(scenario),
-		source: {
-			uri: `scenario://${scenario.id}`,
-			revision: canonicalCandidateDigest$1(scenario)
-		}
-	}));
-	const splits = {
-		train: tasks(trainScenarios),
-		selection: tasks(selectionScenarios),
-		test: tasks(testScenarios)
-	};
-	const developmentUnits = new Set([...splits.train, ...splits.selection].map((task) => task.unitId));
-	const execution = {
-		model: prepared.searchIdentity.model,
-		agent: prepared.searchIdentity.agent,
-		benchmark: {
-			uri: "agent-runtime:improve-splits",
-			revision: canonicalCandidateDigest$1({
-				development: prepared.identity.developmentSplitDigest,
-				test: prepared.identity.finalTestSplitDigest
-			})
-		}
-	};
-	const reservedClaimUsd = Math.max(method.claimReserveUsd ?? 0, searchClaimReserveUsd({
-		testTasks: splits.test.length,
-		reps,
-		cellUsd: Math.max(...lanes.map((lane) => lane.cellUsd))
-	}));
-	const recorder = await SearchRecorder.open({
-		ledger: storage.kind === "filesystem" ? openSearchLedger({
-			path: `${searchDir}/ledger.jsonl`,
-			searchId
-		}) : openSearchLedger({
-			path: `${searchDir}/ledger.jsonl`,
-			searchId,
-			store: storage
-		}),
-		storage
-	}, {
-		subject: prepared.searchIdentity.subject,
-		process: {
-			name: method.name,
-			executionRef: SEARCH_METHOD_SOURCE
-		},
-		artifactKind: "agent-profile",
-		objective: {
-			metric: "composite",
-			direction: "maximize",
-			judge: prepared.searchIdentity.judge,
-			claim
-		},
-		splits: {
-			...splits,
-			heldOutUnits: splits.test.every((task) => !developmentUnits.has(task.unitId))
-		},
-		policy: {
-			expansion: policy.name,
-			allocation: allocation.name,
-			seed
-		},
-		budget: {
-			maxUsd: costCeiling ?? null,
-			maxCells: null,
-			maxNodes: 1 + method.maxExpansions * method.childrenPerProposal,
-			deadline: method.deadline,
-			maxConcurrency: concurrency,
-			reservedClaimUsd: costCeiling === void 0 ? 0 : reservedClaimUsd
-		},
-		containment: null,
-		derivedFrom: null,
-		identity: execution
-	});
-	const nodeOf = (candidateSurface) => {
-		const surface = immutableCandidateValue(candidateSurface);
-		try {
-			return {
-				surface,
-				profile: prepared.materializeCandidate(surface),
-				refusal: null
-			};
-		} catch (error) {
-			return {
-				surface,
-				profile: null,
-				refusal: refusalText(error)
-			};
-		}
+	const execution = searchExecutionIdentity(prepared);
+	const recorder = await openSearchRecorder({
+		method,
+		prepared,
+		claim,
+		splits: searchSplits(claim, splitScenarios),
+		storage,
+		searchId,
+		searchDir,
+		seed,
+		costCeiling,
+		concurrency,
+		execution
+	});
+	const session = {
+		method,
+		prepared,
+		searchId,
+		costLedger,
+		recorder
 	};
 	const profiles = /* @__PURE__ */ new Map();
-	const profiled = profileCodec(prepared);
-	const codec = {
-		node(recorder, node) {
-			const registered = profiled.node(recorder, node);
-			profiles.set(searchNodeId(searchId, registered.artifactDigest), node.profile);
-			return registered;
-		},
-		diff: profiled.diff,
-		load(recorder, node) {
-			const loaded = profiled.load(recorder, node);
-			profiles.set(node.nodeId, loaded.profile);
-			return loaded;
-		}
-	};
+	const codec = registeringProfileCodec(prepared, searchId, profiles);
 	for (const node of (await recorder.state()).nodes()) codec.load(recorder, node);
 	await reconcileInterruptedSearchCalls(costLedger, searchId, lanes);
-	const laneRefusal = (nodeProfile) => {
-		const refusals = lanes.map((lane) => `${lane.name}: ${lane.refusal(nodeProfile)}`);
-		return lanes.some((lane) => lane.refusal(nodeProfile) === void 0) ? null : `no lane can run the profile (${refusals.join("; ")})`;
-	};
-	const root = nodeOf(prepared.baselineSurface);
+	const root = profileNodeOf(prepared, prepared.baselineSurface);
 	if (root.profile) {
-		const refused = laneRefusal(root.profile);
+		const refused = laneRefusal(lanes, root.profile);
 		if (refused) throw new ConfigError(`improve(): the baseline profile cannot run: ${refused}`);
 	}
 	const scenarios = [
@@ -2181,11 +2255,7 @@ async function runSearchImprovement(profile, opts) {
 		...selectionScenarios,
 		...testScenarios
 	];
-	const scenarioIds = /* @__PURE__ */ new Set();
-	for (const scenario of scenarios) {
-		if (scenarioIds.has(scenario.id)) throw new ConfigError(`improve(): scenario '${scenario.id}' appears in more than one split`);
-		scenarioIds.add(scenario.id);
-	}
+	assertDistinctScenarios(scenarios);
 	const executor = searchExecutor({
 		lanes,
 		profileOf(nodeId) {
@@ -2200,167 +2270,164 @@ async function runSearchImprovement(profile, opts) {
 		...workerSlots ? { workerSlots } : {},
 		...budgetPool ? { budgetPool } : {},
 		...trace ? { trace } : {},
-		async runAttempt({ work, lane, context, costLedger: cellLedger, span }) {
-			const nodeProfile = work.artifact.profile;
-			if (!nodeProfile) throw new Error(`improve(): refused node ${work.nodeId} was given a cell`);
-			const profileDigest = canonicalAgentProfileDigest(nodeProfile);
-			let fault;
-			const cell = (await runCampaign({
-				...campaignOptions,
-				...lane.kind === "subscription" && campaignOptions.expectUsage === void 0 ? { expectUsage: "off" } : {},
-				scenarios,
-				judges: prepared.judges.map((judge) => ({
-					...judge,
-					async score(input) {
-						try {
-							return await judge.score(input);
-						} catch (error) {
-							if (isSearchEnvironmentFault(error)) fault = error;
-							throw error;
-						}
-					}
-				})),
-				seed,
-				reps,
-				storage,
-				runDir: `${searchDir}/nodes/${profileDigest.slice(7)}`,
-				dispatchRef: `improve:${evaluationRef}:${profileDigest}`,
-				async dispatch(scenario, ctx) {
-					try {
-						return await agent(nodeProfile, scenario, {
-							...ctx,
-							search: context
-						});
-					} catch (error) {
-						if (isSearchEnvironmentFault(error)) fault = error;
-						throw error;
-					}
-				},
-				cellFilter: ({ scenario, rep }) => scenario.id === work.taskId && rep === work.rep,
-				resumable: true,
-				maxConcurrency: 1,
-				costLedger: cellLedger,
-				costPhase: `search.${work.stage}`,
-				buildTraceWriter: () => ({
-					span,
-					flush: async () => {}
-				}),
-				signal: work.signal
-			})).cells[0];
-			if (!cell) throw new Error(`improve(): cell ${work.cellId} produced no campaign cell`);
-			const result = campaignCellSearchResult(cell, {
-				execution,
-				lane: lane.name
-			});
-			const execRunId = cell.error ? null : executionRunId?.(cell.artifact) ?? null;
-			const settled = faultResult(execRunId && context.trace ? {
-				...result,
-				traceRef: {
-					traceId: context.trace.traceId,
-					execRunId,
-					spansWritten: null,
-					spansDropped: null
-				}
-			} : result, fault);
-			return recordCell && settled.outcome.status !== "errored" ? {
-				...settled,
-				recordCell: (finalResult) => recordCell({
-					cell,
-					search: context,
-					result: finalResult
-				})
-			} : settled;
-		}
-	});
-	const { proposer } = method;
-	const proposerSource = {
-		uri: `proposer:${proposer.kind}`,
-		revision: canonicalCandidateDigest$1({
-			kind: proposer.kind,
-			propose: Function.prototype.toString.call(proposer.propose),
-			decide: proposer.decide ? Function.prototype.toString.call(proposer.decide) : null
+		runAttempt: searchCellRunner({
+			campaignOptions,
+			prepared,
+			agent,
+			executionRunId,
+			recordCell,
+			scenarios,
+			seed,
+			reps,
+			storage,
+			searchDir,
+			evaluationRef,
+			execution
 		})
-	};
-	const proposalPhase = "search.proposal";
-	const port = {
-		name: proposer.kind,
-		kind: "optimizer",
-		source: proposerSource,
-		execution: {
-			kind: "deterministic",
-			source: proposerSource
+	});
+	const startedAt = Date.now();
+	return decideSearchResult({
+		session,
+		codec,
+		result: await runSearch({
+			recorder,
+			root,
+			codec,
+			policy,
+			allocation,
+			proposer: searchProposerPort(session),
+			executor,
+			admit: (node) => admissionRefusal(session, node),
+			maxExpansions: method.maxExpansions,
+			maxAttempts: method.maxAttempts,
+			...signal ? { signal } : {}
+		}),
+		costCeiling,
+		startedAt
+	});
+}
+/** Open the search's ledger: a fresh search records its opening, an interrupted one continues. */
+function openSearchRecorder(input) {
+	const { method, prepared, claim, splits, storage, searchId, searchDir, seed, costCeiling } = input;
+	const { policy, allocation, lanes } = method;
+	const reservedClaimUsd = Math.max(method.claimReserveUsd ?? 0, searchClaimReserveUsd({
+		testTasks: splits.test.length,
+		reps: allocation.reps,
+		cellUsd: Math.max(...lanes.map((lane) => lane.cellUsd))
+	}));
+	return SearchRecorder.open({
+		ledger: storage.kind === "filesystem" ? openSearchLedger({
+			path: `${searchDir}/ledger.jsonl`,
+			searchId
+		}) : openSearchLedger({
+			path: `${searchDir}/ledger.jsonl`,
+			searchId,
+			store: storage
+		}),
+		storage
+	}, {
+		subject: prepared.searchIdentity.subject,
+		process: {
+			name: method.name,
+			executionRef: SEARCH_METHOD_SOURCE
 		},
-		childrenPerProposal: method.childrenPerProposal,
-		async propose(request) {
-			const tags = searchCallTags(searchId, { operation: request.operationId });
-			const state = await recorder.state();
-			const parents = request.parents.map(({ nodeId, artifact }) => ({
-				nodeId,
-				artifact: artifact.surface
-			}));
-			const context = Object.freeze({
-				currentSurface: parents[0]?.artifact ?? prepared.baselineSurface,
-				operator: request.operator,
-				parents,
-				train: searchProposerView(state),
-				summary: renderSearchSummary(state, { split: "train" }),
-				history: [],
-				findings: prepared.findings,
-				populationSize: method.childrenPerProposal,
-				generation: request.expansion,
-				signal: request.signal,
-				costLedger: taggedLedger(costLedger, tags),
-				costPhase: proposalPhase
-			});
-			const decision = proposer.decide?.({ history: [] });
-			const proposed = decision?.stop ? [] : await proposer.propose(context);
-			if (!Array.isArray(proposed)) throw new ConfigError("improve(): the search proposer must return an array");
-			const fresh = costLedger.list({
-				phase: proposalPhase,
-				tags
-			});
-			return {
-				children: proposed.slice(0, method.childrenPerProposal).map((child) => isProposedCandidate(child) ? {
-					artifact: nodeOf(child.surface),
-					label: child.label,
-					rationale: child.rationale,
-					...child.attribution ? { attribution: child.attribution } : {}
-				} : {
-					artifact: nodeOf(child),
-					label: "",
-					rationale: ""
-				}),
-				...decision?.stop ? { stop: decision.reason ?? "the proposer decided to stop" } : {},
-				accounting: searchReceiptAccounting(fresh),
-				execution: searchProposalExecution(fresh, prepared.searchIdentity.model.provider, proposerSource)
-			};
+		artifactKind: "agent-profile",
+		objective: {
+			metric: "composite",
+			direction: "maximize",
+			judge: prepared.searchIdentity.judge,
+			claim
+		},
+		splits,
+		policy: {
+			expansion: policy.name,
+			allocation: allocation.name,
+			seed
+		},
+		budget: {
+			maxUsd: costCeiling ?? null,
+			maxCells: null,
+			maxNodes: 1 + method.maxExpansions * method.childrenPerProposal,
+			deadline: method.deadline,
+			maxConcurrency: input.concurrency,
+			reservedClaimUsd: costCeiling === void 0 ? 0 : reservedClaimUsd
+		},
+		containment: null,
+		derivedFrom: null,
+		identity: input.execution
+	});
+}
+/** The request is a search with a claim that can be powered, and every split has scenarios. */
+function assertSearchRequest(method, inputClaim, splits) {
+	if (!isImproveSearchMethod(method)) throw new ConfigError("improve(): a search needs method: searchMethod(...)");
+	const claim = defineEvaluationClaim(inputClaim);
+	if (claim.minimumEffect === void 0) throw new ConfigError("improve(): a search claim needs minimumEffect for its power check");
+	for (const [name, split] of Object.entries(splits)) if (!Array.isArray(split) || split.length === 0) throw new ConfigError(`improve(): a search needs at least one of ${name}`);
+	return claim;
+}
+function assertDistinctScenarios(scenarios) {
+	const scenarioIds = /* @__PURE__ */ new Set();
+	for (const scenario of scenarios) {
+		if (scenarioIds.has(scenario.id)) throw new ConfigError(`improve(): scenario '${scenario.id}' appears in more than one split`);
+		scenarioIds.add(scenario.id);
+	}
+}
+/** The search tasks of each split, and whether the test units are held out of development. */
+function searchSplits(claim, scenarios) {
+	const unitOf = (scenario) => summarizeEvaluationUnits(claim, [scenario]).units[0].id;
+	const tasks = (list) => list.map((scenario) => ({
+		taskId: scenario.id,
+		unitId: unitOf(scenario),
+		source: {
+			uri: `scenario://${scenario.id}`,
+			revision: canonicalCandidateDigest$1(scenario)
 		}
+	}));
+	const splits = {
+		train: tasks(scenarios.trainScenarios),
+		selection: tasks(scenarios.selectionScenarios),
+		test: tasks(scenarios.testScenarios)
 	};
-	const admit = (node) => {
-		if (node.refusal !== null || node.profile === null) return node.refusal;
-		try {
-			prepared.admitCandidate(node.profile, node.surface);
-		} catch (error) {
-			return refusalText(error);
+	const developmentUnits = new Set([...splits.train, ...splits.selection].map((task) => task.unitId));
+	return {
+		...splits,
+		heldOutUnits: splits.test.every((task) => !developmentUnits.has(task.unitId))
+	};
+}
+function searchExecutionIdentity(prepared) {
+	return {
+		model: prepared.searchIdentity.model,
+		agent: prepared.searchIdentity.agent,
+		benchmark: {
+			uri: "agent-runtime:improve-splits",
+			revision: canonicalCandidateDigest$1({
+				development: prepared.identity.developmentSplitDigest,
+				test: prepared.identity.finalTestSplitDigest
+			})
 		}
-		const paths = privateValuePaths([node.surface]);
-		if (paths.length > 0) return `the surface carries a credential or private value at ${paths.slice(0, 8).join(", ")}`;
-		return laneRefusal(node.profile);
 	};
-	const startedAt = Date.now();
-	const result = await runSearch({
-		recorder,
-		root,
-		codec,
-		policy,
-		allocation,
-		proposer: port,
-		executor,
-		admit,
-		maxExpansions: method.maxExpansions,
-		maxAttempts: method.maxAttempts,
-		...signal ? { signal } : {}
-	});
+}
+/** Why no lane can run the profile, or null when one can. */
+function laneRefusal(lanes, nodeProfile) {
+	const refusals = lanes.map((lane) => `${lane.name}: ${lane.refusal(nodeProfile)}`);
+	return lanes.some((lane) => lane.refusal(nodeProfile) === void 0) ? null : `no lane can run the profile (${refusals.join("; ")})`;
+}
+/** Why a node is refused admission to the search, or null when it is admitted. */
+function admissionRefusal({ prepared, method }, node) {
+	if (node.refusal !== null || node.profile === null) return node.refusal;
+	try {
+		prepared.admitCandidate(node.profile, node.surface);
+	} catch (error) {
+		return searchRefusalText(error);
+	}
+	const paths = privateValuePaths([node.surface]);
+	if (paths.length > 0) return `the surface carries a credential or private value at ${paths.slice(0, 8).join(", ")}`;
+	return laneRefusal(method.lanes, node.profile);
+}
+/** Read the closed search back from its ledger and decide whether its leader ships. */
+async function decideSearchResult(input) {
+	const { session, codec, result, costCeiling, startedAt } = input;
+	const { method, prepared, searchId, costLedger, recorder } = session;
 	const { state } = result;
 	const claimResult = result.claim;
 	if (!claimResult || !result.claimVerification) throw new Error(`improve(): search ${searchId} closed without a claim`);
@@ -2411,77 +2478,6 @@ async function runSearchImprovement(profile, opts) {
 		async dispose() {}
 	};
 }
-/** Profiles as search artifacts: nodes by profile digest, edges by profile diffs. */
-function profileCodec(prepared) {
-	const surfaceId = prepared.surface;
-	return {
-		node(recorder, node) {
-			if (node.profile) {
-				const artifact = recorder.blob("agent-profile", {
-					kind: "agent-profile",
-					profile: node.profile
-				});
-				return {
-					artifactDigest: canonicalAgentProfileDigest(node.profile),
-					artifact,
-					surfaces: [{
-						surfaceId,
-						kind: "agent-profile",
-						artifact
-					}]
-				};
-			}
-			const artifact = recorder.blob("surface", {
-				kind: "unmaterialized-surface",
-				surface: node.surface,
-				refusal: node.refusal
-			});
-			return {
-				artifactDigest: canonicalCandidateDigest$1({
-					kind: "unmaterialized-surface",
-					surface: node.surface
-				}),
-				artifact,
-				surfaces: [{
-					surfaceId,
-					kind: "agent-profile",
-					artifact
-				}]
-			};
-		},
-		diff(recorder, parent, child) {
-			if (!parent.profile || !child.profile) return { unknown: "a surface that does not materialize has no profile to diff" };
-			const diffs = diffAgentProfiles(parent.profile, child.profile);
-			const to = canonicalAgentProfileDigest(child.profile);
-			if (canonicalAgentProfileDigest(diffs.reduce(applyAgentProfileDiff, parent.profile)) !== to) return { unknown: "the Interface profile diffs do not reproduce the child profile" };
-			return recorder.blob("diff", {
-				kind: "agent-profile-diff",
-				from: canonicalAgentProfileDigest(parent.profile),
-				to,
-				diffs
-			});
-		},
-		load(recorder, node) {
-			const stored = recorder.readBlob(node.artifact);
-			if (stored.kind === "agent-profile") {
-				const parsed = agentProfileSchema.safeParse(stored.profile);
-				if (!parsed.success) throw new Error(`improve(): node ${node.nodeId} holds an invalid AgentProfile`);
-				const loaded = immutableCandidateValue(parsed.data);
-				return {
-					surface: prepared.surfaceOf(loaded),
-					profile: loaded,
-					refusal: null
-				};
-			}
-			if (stored.kind === "unmaterialized-surface" && stored.surface !== void 0) return {
-				surface: stored.surface,
-				profile: null,
-				refusal: stored.refusal ?? null
-			};
-			throw new Error(`improve(): node ${node.nodeId} holds no profile search artifact`);
-		}
-	};
-}
 /** Everything that decides which search a call continues. */
 function searchMethodDescriptor(method) {
 	return {
@@ -2504,6 +2500,148 @@ function searchMethodDescriptor(method) {
 		maxAttempts: method.maxAttempts
 	};
 }
+const PROPOSAL_PHASE = "search.proposal";
+function searchProposerPort(session) {
+	const { method, prepared, recorder, costLedger, searchId } = session;
+	const { proposer } = method;
+	const proposerSource = {
+		uri: `proposer:${proposer.kind}`,
+		revision: canonicalCandidateDigest$1({
+			kind: proposer.kind,
+			propose: Function.prototype.toString.call(proposer.propose),
+			decide: proposer.decide ? Function.prototype.toString.call(proposer.decide) : null
+		})
+	};
+	return {
+		name: proposer.kind,
+		kind: "optimizer",
+		source: proposerSource,
+		execution: {
+			kind: "deterministic",
+			source: proposerSource
+		},
+		childrenPerProposal: method.childrenPerProposal,
+		async propose(request) {
+			const tags = searchCallTags(searchId, { operation: request.operationId });
+			const state = await recorder.state();
+			const parents = request.parents.map(({ nodeId, artifact }) => ({
+				nodeId,
+				artifact: artifact.surface
+			}));
+			const context = Object.freeze({
+				currentSurface: parents[0]?.artifact ?? prepared.baselineSurface,
+				operator: request.operator,
+				parents,
+				train: searchProposerView(state),
+				summary: renderSearchSummary(state, { split: "train" }),
+				history: [],
+				findings: prepared.findings,
+				populationSize: method.childrenPerProposal,
+				generation: request.expansion,
+				signal: request.signal,
+				costLedger: taggedLedger(costLedger, tags),
+				costPhase: PROPOSAL_PHASE
+			});
+			const decision = proposer.decide?.({ history: [] });
+			const proposed = decision?.stop ? [] : await proposer.propose(context);
+			if (!Array.isArray(proposed)) throw new ConfigError("improve(): the search proposer must return an array");
+			const fresh = costLedger.list({
+				phase: PROPOSAL_PHASE,
+				tags
+			});
+			return {
+				children: proposed.slice(0, method.childrenPerProposal).map((child) => isProposedCandidate(child) ? {
+					artifact: profileNodeOf(prepared, child.surface),
+					label: child.label,
+					rationale: child.rationale,
+					...child.attribution ? { attribution: child.attribution } : {}
+				} : {
+					artifact: profileNodeOf(prepared, child),
+					label: "",
+					rationale: ""
+				}),
+				...decision?.stop ? { stop: decision.reason ?? "the proposer decided to stop" } : {},
+				accounting: searchReceiptAccounting(fresh),
+				execution: searchProposalExecution(fresh, prepared.searchIdentity.model.provider, proposerSource)
+			};
+		}
+	};
+}
+/** The executor's cell runner for one search. */
+function searchCellRunner(env) {
+	const { campaignOptions, prepared, executionRunId, recordCell, execution } = env;
+	return async ({ work, lane, context, costLedger: cellLedger, span }) => {
+		const nodeProfile = work.artifact.profile;
+		if (!nodeProfile) throw new Error(`improve(): refused node ${work.nodeId} was given a cell`);
+		const profileDigest = canonicalAgentProfileDigest(nodeProfile);
+		let fault;
+		const cell = (await runCampaign({
+			...campaignOptions,
+			...lane.kind === "subscription" && campaignOptions.expectUsage === void 0 ? { expectUsage: "off" } : {},
+			scenarios: env.scenarios,
+			judges: prepared.judges.map((judge) => ({
+				...judge,
+				async score(input) {
+					try {
+						return await judge.score(input);
+					} catch (error) {
+						if (isSearchEnvironmentFault(error)) fault = error;
+						throw error;
+					}
+				}
+			})),
+			seed: env.seed,
+			reps: env.reps,
+			storage: env.storage,
+			runDir: `${env.searchDir}/nodes/${profileDigest.slice(7)}`,
+			dispatchRef: `improve:${env.evaluationRef}:${profileDigest}`,
+			async dispatch(scenario, ctx) {
+				try {
+					return await env.agent(nodeProfile, scenario, {
+						...ctx,
+						search: context
+					});
+				} catch (error) {
+					if (isSearchEnvironmentFault(error)) fault = error;
+					throw error;
+				}
+			},
+			cellFilter: ({ scenario, rep }) => scenario.id === work.taskId && rep === work.rep,
+			resumable: true,
+			maxConcurrency: 1,
+			costLedger: cellLedger,
+			costPhase: `search.${work.stage}`,
+			buildTraceWriter: () => ({
+				span,
+				flush: async () => {}
+			}),
+			signal: work.signal
+		})).cells[0];
+		if (!cell) throw new Error(`improve(): cell ${work.cellId} produced no campaign cell`);
+		const result = campaignCellSearchResult(cell, {
+			execution,
+			lane: lane.name
+		});
+		const execRunId = cell.error ? null : executionRunId?.(cell.artifact) ?? null;
+		const settled = faultResult(execRunId && context.trace ? {
+			...result,
+			traceRef: {
+				traceId: context.trace.traceId,
+				execRunId,
+				spansWritten: null,
+				spansDropped: null
+			}
+		} : result, fault);
+		return recordCell && settled.outcome.status !== "errored" ? {
+			...settled,
+			recordCell: (finalResult) => recordCell({
+				cell,
+				search: context,
+				result: finalResult
+			})
+		} : settled;
+	};
+}
 /**
 * An environment fault the agent raised settles retryable. The campaign reports every error as
 * final because it applies its own retry policy; here the kernel owns retries.
@@ -2516,16 +2654,12 @@ function faultResult(result, fault) {
 			...result.outcome,
 			error: {
 				code: "environment-fault",
-				message: refusalText(fault),
+				message: searchRefusalText(fault),
 				retryable: true
 			}
 		}
 	};
 }
-/** A refusal as the ledger stores it: redacted with the share profile. */
-function refusalText(error) {
-	return redact(error instanceof Error ? error.message : String(error), { profile: "share" }).value;
-}
 //#endregion
 //#region src/improvement/training.ts
 function positiveLimit(value, label) {
@@ -2540,10 +2674,9 @@ async function hashFile(path, maximum, signal, capture = false) {
 		const hash = createHash("sha256");
 		const chunks = [];
 		let bytes = 0;
-		for await (const chunk of file.createReadStream({
-			autoClose: false,
-			signal
-		})) {
+		signal.throwIfAborted();
+		for await (const chunk of file.createReadStream({ autoClose: false })) {
+			signal.throwIfAborted();
 			bytes += chunk.length;
 			if (bytes > maximum) throw new Error("artifact exceeded its byte limit");
 			if (bytes > before.size) throw new Error("artifact changed while being hashed");
@@ -2918,4 +3051,4 @@ async function improve(profileOrCode, opts) {
 //#endregion
 export { assertProfileTrainingIsHeldOut as a, withMethodRuntimeControls as c, commandVerifier as d, addRuntimeUsage as f, assertCandidateValidator as i, rethrowAfterCleanup as l, isUsageAmount as m, createCommandProfileTrainer as n, parseExecutionRef as o, createRuntimeUsageTotals as p, searchMethod as r, privateValuePaths as s, improve as t, agenticGenerator as u };
 
-//# sourceMappingURL=improve-BOXTLWJ3.js.map
+//# sourceMappingURL=improve-BZXt2qM0.js.map