@tangle-network/agent-runtime 0.277.0 → 0.279.0

package/dist/{improvement-cycle-DQyN0__A.js → improvement-cycle-Bi43xCVa.js}

@@ -1,6 +1,6 @@
-import { $i as detachedSnapshot, Ia as armDeadlineTimer, Ot as createExecutor, Qr as runSettledCommand, br as linkAbort, ui as terminateProcessTreeAndConfirm, xr as runAbortable } from "./supervisor-CjNbOcLO.js";
+import { $i as detachedSnapshot, At as createExecutor, Cr as runAbortable, Ia as armDeadlineTimer, Qr as runSettledCommand, Sr as linkAbort, ui as terminateProcessTreeAndConfirm } from "./supervisor-DtlPj9me.js";
 import { i as ConfigError } from "./errors-DodWX-cb.js";
-import { A as collectAgentTurn, O as optimizerMethod, a as defaultStructuralRolloutPolicy, j as streamAgentTurn } from "./structural-rollout-VR-j5t9d.js";
+import { A as collectAgentTurn, O as optimizerMethod, a as defaultStructuralRolloutPolicy, j as streamAgentTurn } from "./structural-rollout-D-0X6lsU.js";
 import { a as concreteProfileModel, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { A as verifyCanonicalCandidateDocument, C as canonicalCandidateDigest$1, D as immutableCandidateValue, O as omitTopLevelDigest, S as canonicalCandidateBytes$1, k as sha256Bytes$1, w as canonicalCandidateDocument } from "./workspace-archive-C9lgf77y.js";
 import { i as syncDurableDirectory, r as publishExclusiveDurableFile } from "./durable-file-DWQA4ooo.js";
@@ -15,10 +15,11 @@ import { constants, existsSync, mkdtempSync, readFileSync, readdirSync, realpath
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { chmod, mkdir, mkdtemp, open, realpath, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { isDeepStrictEqual } from "node:util";
+import { redact } from "@tangle-network/agent-eval/traces";
 import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
-import { campaignScenarioIdentity, campaignSplitDigestFromIdentities, compareOptimizationMethods, decodeExternalTextCandidate, gitWorktreeAdapter, readExternalOptimizerObservationArtifact, readGepaCandidatePopulationArtifact, verifyCodeSurface } from "@tangle-network/agent-eval/campaign";
+import { SearchRecorder, campaignCellSearchResult, campaignScenarioIdentity, campaignSplitDigestFromIdentities, compareOptimizationMethods, createRunCostLedger, fsCampaignStorage, gitWorktreeAdapter, incumbent, isProposedCandidate, openSearchLedger, renderSearchSummary, resolveRunDir, runCampaign, runSearch, searchClaimReserveUsd, searchProposalExecution, searchProposerView, searchReceiptAccounting, uniform, verifyCodeSurface, verifySearchHistoryArtifact } from "@tangle-network/agent-eval/campaign";
 import { measuredComparisonFromAgentProfileImprovementExperiment, measuredComparisonFromCandidateExperiment, runAgentProfileImprovementExperiment, runCandidateExperiment, sealAgentProfileImprovementExperiment, sealAgentProfileImprovementSuite, sealAgentProfileImprovementTask, sealCandidateExperiment, selfImprove, verifyAgentProfileImprovementExperimentComparison, verifyCandidateExperiment, verifyCandidateExperimentComparison } from "@tangle-network/agent-eval/contract";
+import { defineEvaluationClaim, summarizeEvaluationUnits } from "@tangle-network/agent-eval/experiment";
 //#region src/improvement/worktree-tree.ts
 /**
 * The exact content of a candidate worktree, as a Git tree object.
@@ -1585,37 +1586,6 @@ async function runCodeImprovement(opts) {
 	};
 }
 //#endregion
-//#region src/improvement/candidate-validation.ts
-/** One spelling of the execution-identity rule for optimization, training, and the harness. */
-function parseExecutionRef(value, label) {
-	const parsed = sha256DigestSchema.safeParse(value);
-	if (!parsed.success) throw new ConfigError(`${label}: executionRef must be a lowercase sha256:<64 hex> digest`);
-	return parsed.data;
-}
-/** Validate the callback itself before any optimizer, trainer, or candidate work starts. */
-function assertCandidateValidator(validator) {
-	if (validator !== void 0 && typeof validator !== "function") throw new ConfigError("validateCandidate must be a function when present");
-}
-/** A validator accepts synchronously by returning void, or rejects by throwing. */
-function validateProfileCandidate(validator, input) {
-	assertCandidateValidator(validator);
-	const result = validator?.(Object.freeze(input));
-	if (result !== void 0) {
-		Promise.resolve(result).catch(() => {});
-		throw new ConfigError("candidate validators must return void synchronously or throw");
-	}
-}
-/**
-* Refuse exact held-out content digests already declared in this profile's training lineage.
-* Both training and trainer-visible validation rows are exposure. This is an exact
-* provenance check, not fuzzy decontamination or proof that undeclared training was fresh.
-*/
-function assertProfileTrainingIsHeldOut(profile, heldOutDigests) {
-	const training = profile.metadata?.training;
-	if (!training) return;
-	for (const receipt of [training.receipt, ...training.ancestors]) if (receipt.dataset.tasks.some((task) => heldOutDigests.has(task.contentDigest))) throw new ConfigError("known training exposure overlaps held-out evaluation");
-}
-//#endregion
 //#region src/improvement/method-controls.ts
 const methodRuntimeControls = Symbol("agent-runtime.improvement.method-runtime-controls");
 function withMethodRuntimeControls(method, controls) {
@@ -1711,6 +1681,49 @@ function methodHistoricalReceipts(ledger, optimizerRun, invocationId) {
 	return ledger.list({ tags: { optimizerRun } }).filter((receipt) => receipt.tags?.[INVOCATION_TAG] !== invocationId);
 }
 //#endregion
+//#region src/improvement/candidate-validation.ts
+/** One spelling of the execution-identity rule for optimization, training, and the harness. */
+function parseExecutionRef(value, label) {
+	const parsed = sha256DigestSchema.safeParse(value);
+	if (!parsed.success) throw new ConfigError(`${label}: executionRef must be a lowercase sha256:<64 hex> digest`);
+	return parsed.data;
+}
+/** Validate the callback itself before any optimizer, trainer, or candidate work starts. */
+function assertCandidateValidator(validator) {
+	if (validator !== void 0 && typeof validator !== "function") throw new ConfigError("validateCandidate must be a function when present");
+}
+/** A validator accepts synchronously by returning void, or rejects by throwing. */
+function validateProfileCandidate(validator, input) {
+	assertCandidateValidator(validator);
+	const result = validator?.(Object.freeze(input));
+	if (result !== void 0) {
+		Promise.resolve(result).catch(() => {});
+		throw new ConfigError("candidate validators must return void synchronously or throw");
+	}
+}
+/**
+* Refuse exact held-out content digests already declared in this profile's training lineage.
+* Both training and trainer-visible validation rows are exposure. This is an exact
+* provenance check, not fuzzy decontamination or proof that undeclared training was fresh.
+*/
+function assertProfileTrainingIsHeldOut(profile, heldOutDigests) {
+	const training = profile.metadata?.training;
+	if (!training) return;
+	for (const receipt of [training.receipt, ...training.ancestors]) if (receipt.dataset.tasks.some((task) => heldOutDigests.has(task.contentDigest))) throw new ConfigError("known training exposure overlaps held-out evaluation");
+}
+/**
+* JSON paths of credential and private values in candidate content, found by
+* the redaction core, which names each value it would change. A candidate that
+* leaves Runtime (an external optimizer, a search ledger) is refused on any.
+*/
+function privateValuePaths(values) {
+	return [...new Set(values.flatMap((value) => redact(value).report.findings.map((finding) => jsonPathOf(finding.path))))];
+}
+/** `/remote/url` or `/tools/0/env` as `$.remote.url` or `$.tools[0].env`. */
+function jsonPathOf(pointer) {
+	return pointer.split("/").slice(1).map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).reduce((path, segment) => /^\d+$/.test(segment) ? `${path}[${segment}]` : `${path}.${segment}`, "$");
+}
+//#endregion
 //#region src/improvement/method-identity.ts
 function buildMethodEvaluationIdentity(input) {
 	const optimizationReps = input.optimizationRunOptions?.reps ?? 1;
@@ -1777,150 +1790,23 @@ function judgeDescriptor(judge) {
 	};
 }
 //#endregion
-//#region src/improvement/method-execution.ts
-function resolveOptimizationMethod(source, context) {
-	const method = typeof source === "function" ? source(context) : source;
-	if (!method || typeof method !== "object" || typeof method.name !== "string" || method.name.trim() !== method.name || method.name.length === 0 || typeof method.optimize !== "function") throw new ConfigError("improve(): method must be a complete OptimizationMethod with a trimmed name and optimize(input)");
-	return method;
-}
-function materializationError(error) {
-	if (error instanceof Error) return {
-		name: error.name,
-		message: error.message
-	};
-	return {
-		name: "Error",
-		message: typeof error === "string" ? error : "candidate materialization threw a non-Error value"
-	};
-}
-function profileCandidatePopulation(provenance, baselineProfile, materializeProfile, winnerSurface, storage) {
-	const observationSummary = provenance?.observations;
-	const graphSummary = provenance?.gepaCandidatePopulation;
-	if (!observationSummary && !graphSummary) return Object.freeze({
-		status: "unavailable",
-		reason: "method-did-not-report-candidate-population"
-	});
-	const observations = observationSummary ? readExternalOptimizerObservationArtifact({
-		summary: observationSummary,
-		...storage ? { storage } : {}
-	}) : void 0;
-	const graph = graphSummary ? readGepaCandidatePopulationArtifact({ summary: graphSummary }) : void 0;
-	if (!graph && (observations?.candidates.length ?? 0) === 0) return Object.freeze({
-		status: "unavailable",
-		reason: "method-did-not-report-candidate-population"
-	});
-	const entries = /* @__PURE__ */ new Map();
-	const entryFor = (candidateDigest, value) => {
-		const existing = entries.get(candidateDigest);
-		if (existing) {
-			if (!isDeepStrictEqual(existing.value, value)) throw new ConfigError(`improve(): optimizer artifacts disagree on candidate ${candidateDigest}`);
-			return existing;
-		}
-		const entry = {
-			candidateDigest,
-			value: immutableCandidateValue(value),
-			lineageNodes: []
-		};
-		entries.set(candidateDigest, entry);
-		return entry;
-	};
-	for (const submitted of observations?.candidates ?? []) {
-		const entry = entryFor(submitted.candidateDigest, decodeExternalTextCandidate(submitted.candidate));
-		entry.observation = {
-			proposalSequence: submitted.proposalSequence,
-			artifact: {
-				path: submitted.provenance.path,
-				sha256: submitted.provenance.sha256
-			}
-		};
-	}
-	for (const graphCandidate of graph?.candidates ?? []) entryFor(graphCandidate.candidateDigest, decodeExternalTextCandidate(graphCandidate.candidate)).lineageNodes.push({
-		index: graphCandidate.index,
-		parentIndices: [...graphCandidate.parentIndices],
-		aggregateScore: graphCandidate.aggregateScore,
-		selectionScores: graphCandidate.selectionScores.map((score) => ({ ...score })),
-		discoveryEvaluationCount: graphCandidate.discoveryEvaluationCount
-	});
-	if (graph) {
-		const best = graph.candidates.find((candidate) => candidate.index === graph.bestIndex);
-		if (!best) throw new ConfigError(`improve(): GEPA candidate population has no bestIndex node ${graph.bestIndex}`);
-		if (!isDeepStrictEqual(decodeExternalTextCandidate(best.candidate), winnerSurface)) throw new ConfigError("improve(): method winner does not equal the verified GEPA bestIndex candidate");
-	} else if (![...entries.values()].some((entry) => isDeepStrictEqual(entry.value, winnerSurface))) throw new ConfigError("improve(): method winner does not appear in the verified optimizer observations");
-	let materializedCandidates = 0;
-	let refusedCandidates = 0;
-	const candidates = [...entries.values()].map((entry) => {
-		const source = {
-			candidateDigest: entry.candidateDigest,
-			...entry.observation ? { observation: entry.observation } : {},
-			lineage: entry.lineageNodes.length > 0 && graph ? {
-				status: "available",
-				artifact: {
-					path: graph.summary.path,
-					sha256: graph.summary.sha256
-				},
-				nodes: entry.lineageNodes
-			} : {
-				status: "unavailable",
-				reason: "optimizer-did-not-report-candidate-lineage"
-			}
-		};
-		const surfaceDigest = canonicalCandidateDigest$1(entry.value);
-		let candidateProfile;
-		try {
-			candidateProfile = materializeProfile(entry.value);
-		} catch (error) {
-			refusedCandidates += 1;
-			return {
-				status: "refused",
-				source,
-				value: entry.value,
-				surfaceDigest,
-				error: materializationError(error)
-			};
-		}
-		const profileDigest = canonicalAgentProfileDigest(candidateProfile);
-		const diffs = diffAgentProfiles(baselineProfile, candidateProfile);
-		if (canonicalAgentProfileDigest(diffs.reduce(applyAgentProfileDiff, baselineProfile)) !== profileDigest) throw new ConfigError(`improve(): Interface profile diffs do not reproduce optimizer candidate ${entry.candidateDigest}`);
-		materializedCandidates += 1;
-		return {
-			status: "materialized",
-			source,
-			value: entry.value,
-			surfaceDigest,
-			profile: candidateProfile,
-			profileDigest,
-			diffs,
-			diffDigests: diffs.map(canonicalCandidateDigest$1)
-		};
-	});
-	return immutableCandidateValue({
-		status: "available",
-		source: {
-			...observations ? { observations: {
-				path: observations.summary.path,
-				sha256: observations.summary.sha256
-			} } : {},
-			...graph ? { gepaCandidateGraph: {
-				path: graph.summary.path,
-				sha256: graph.summary.sha256,
-				bestIndex: graph.bestIndex
-			} } : {}
-		},
-		uniqueCandidates: entries.size,
-		observedCandidates: observations?.candidates.length ?? 0,
-		gepaCandidateNodes: graph?.candidates.length ?? 0,
-		materializedCandidates,
-		refusedCandidates,
-		candidates
-	});
-}
-async function runMethodImprovement(profile, opts) {
-	const { surface = "prompt", executionRef: inputExecutionRef, method: methodSource, agent, validateCandidate, findings: inputFindings = [], skills, profileComponents, optimizationRunOptions, minimumLift = 0, ...comparisonOptions } = opts;
+//#region src/improvement/profile-improvement.ts
+/**
+* What every profile improvement prepares before any optimizer or search runs:
+* the exact surface and its baseline, the evaluation identity, identified
+* judges, the identities a search ledger records, and one materializer that
+* admits a candidate only after the held-out and caller checks. `improve()`
+* with an external method and with `searchMethod` share it, so a candidate is
+* materialized and admitted the same way on both paths.
+*/
+function prepareProfileImprovement(profile, input) {
+	const { surface = "prompt", validateCandidate, skills, profileComponents, minimumLift = 0 } = input;
 	assertCandidateValidator(validateCandidate);
 	if (!Number.isFinite(minimumLift) || minimumLift < 0) throw new ConfigError("improve(): minimumLift must be a finite number greater than or equal to 0");
 	if (profileComponents && surface !== "agent-profile") throw new ConfigError("improve(): profileComponents is valid only with surface 'agent-profile'");
-	const executionRef = parseExecutionRef(inputExecutionRef, "improve()");
-	const findings = immutableCandidateValue([...assertProposalFindings(inputFindings, "improve() method findings")]);
+	if (input.subject !== void 0 && (typeof input.subject !== "string" || !input.subject.trim() || input.subject !== input.subject.trim())) throw new ConfigError("improve(): subject must be a trimmed non-empty string");
+	const executionRef = parseExecutionRef(input.executionRef, "improve()");
+	const findings = immutableCandidateValue([...assertProposalFindings(input.findings ?? [], "improve() method findings")]);
 	const preparedSurface = prepareProfileSurface(profile, surface, skills, profileComponents);
 	const baselineSurface = preparedSurface.surface;
 	const baselineValue = immutableCandidateValue(preparedSurface.value);
@@ -1933,28 +1819,25 @@ async function runMethodImprovement(profile, opts) {
 		skills,
 		validateCandidate,
 		findings,
-		trainScenarios: comparisonOptions.trainScenarios,
-		selectionScenarios: comparisonOptions.selectionScenarios,
-		testScenarios: comparisonOptions.testScenarios,
-		judges: comparisonOptions.judges,
-		seed: comparisonOptions.seed,
-		reps: comparisonOptions.reps,
-		costCeiling: comparisonOptions.costCeiling,
-		optimizationRunOptions
+		trainScenarios: input.trainScenarios,
+		selectionScenarios: input.selectionScenarios,
+		testScenarios: input.testScenarios,
+		judges: input.judges,
+		seed: input.seed,
+		reps: input.reps,
+		costCeiling: input.costCeiling,
+		optimizationRunOptions: input.optimizationRunOptions
 	});
-	const { evaluationRef, developmentSplitDigest, finalTestSplitDigest, scenarioPartitions } = identity;
-	const dispatchRef = `improve:${evaluationRef}`;
-	const identifiedJudges = comparisonOptions.judges.map((judge, index) => Object.freeze({
+	const judges = input.judges.map((judge, index) => Object.freeze({
 		...judge,
 		judgeVersion: canonicalCandidateDigest$1({
-			evaluationRef,
+			evaluationRef: identity.evaluationRef,
 			descriptor: identity.judgeDescriptors[index]
 		})
 	}));
 	const rawMaterializeProfile = createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents);
-	const runtimeInvocationId = `runtime-optimization:${randomUUID()}`;
 	const baselineSurfaceDigest = canonicalCandidateDigest$1(baselineSurface);
-	const heldOutDigests = new Set(scenarioPartitions.finalTest.map((task) => task.scenarioDigest));
+	const heldOutDigests = new Set(identity.scenarioPartitions.finalTest.map((task) => task.scenarioDigest));
 	const validatedCandidates = /* @__PURE__ */ new Set();
 	const validateMaterialized = (validator, candidate, candidateSurface, isBaseline) => {
 		const prepared = prepareProfileSurface(candidate, surface, skills, profileComponents);
@@ -1966,28 +1849,96 @@ async function runMethodImprovement(profile, opts) {
 			isBaseline
 		});
 	};
+	const admitCandidate = (candidate, candidateSurface) => {
+		const candidateDigest = canonicalCandidateDigest$1(candidateSurface);
+		if (validatedCandidates.has(candidateDigest)) return;
+		assertProfileTrainingIsHeldOut(candidate, heldOutDigests);
+		validateMaterialized(validateCandidate, candidate, immutableCandidateValue(candidateSurface), candidateDigest === baselineSurfaceDigest);
+		validatedCandidates.add(candidateDigest);
+	};
 	const materializeProfile = (candidateSurface) => {
 		const candidate = rawMaterializeProfile(candidateSurface);
-		const candidateDigest = canonicalCandidateDigest$1(candidateSurface);
-		if (!validatedCandidates.has(candidateDigest)) {
-			assertProfileTrainingIsHeldOut(candidate, heldOutDigests);
-			validateMaterialized(validateCandidate, candidate, immutableCandidateValue(candidateSurface), candidateDigest === baselineSurfaceDigest);
-			validatedCandidates.add(candidateDigest);
-		}
+		admitCandidate(candidate, candidateSurface);
 		return candidate;
 	};
 	materializeProfile(baselineSurface);
+	return {
+		profile,
+		surface,
+		executionRef,
+		findings,
+		minimumLift,
+		baselineSurface,
+		baselineValue,
+		baselineProfileDigest,
+		identity,
+		invocationId: `runtime-optimization:${randomUUID()}`,
+		judges,
+		searchIdentity: Object.freeze({
+			subject: input.subject ?? profile.name ?? "agent-profile",
+			agent: {
+				uri: "agent-runtime:improve-execution-ref",
+				revision: executionRef
+			},
+			judge: {
+				uri: "agent-runtime:improve-judges",
+				revision: canonicalCandidateDigest$1(identity.judgeDescriptors)
+			},
+			model: profileModel(profile)
+		}),
+		surfaceOf: (candidate) => prepareProfileSurface(candidate, surface, skills, profileComponents).surface,
+		materializeCandidate: rawMaterializeProfile,
+		admitCandidate,
+		materializeProfile,
+		validateMaterialized
+	};
+}
+/** The profile's model hint as a moving alias; each cell records what it resolved. */
+function profileModel(profile) {
+	const hint = profile.model?.default;
+	if (!hint) return {
+		provider: "unspecified",
+		alias: "unspecified",
+		unknown: "the profile names no model; each cell records the model it resolved"
+	};
+	return {
+		provider: profile.model?.provider ?? "unspecified",
+		alias: hint,
+		unknown: "the profile names a model hint, not a snapshot; each cell records the model it resolved"
+	};
+}
+//#endregion
+//#region src/improvement/method-execution.ts
+function resolveOptimizationMethod(source, context) {
+	const method = typeof source === "function" ? source(context) : source;
+	if (!method || typeof method !== "object" || typeof method.name !== "string" || method.name.trim() !== method.name || method.name.length === 0 || typeof method.optimize !== "function") throw new ConfigError("improve(): method must be a complete OptimizationMethod with a trimmed name and optimize(input)");
+	return method;
+}
+/**
+* Run one complete method, then compare its winner with the baseline on the
+* held-out test split. A method that records its search (GEPA and SkillOpt do
+* through `officialGepa` and `officialSkillOpt`) must close its ledger; Runtime
+* replays the bytes and returns the receipt. A method that records none
+* returns `searchHistory: null`: its lineage is unknown, not empty.
+*/
+async function runMethodImprovement(profile, opts) {
+	const { surface: _surface, executionRef: _executionRef, method: methodSource, agent, validateCandidate: _validateCandidate, findings: _findings, skills: _skills, profileComponents: _profileComponents, optimizationRunOptions, minimumLift: _minimumLift, subject: _subject, ...comparisonOptions } = opts;
+	const prepared = prepareProfileImprovement(profile, opts);
+	const { surface, identity, invocationId, baselineSurface, materializeProfile, validateMaterialized, minimumLift } = prepared;
+	const { evaluationRef, developmentSplitDigest, finalTestSplitDigest, scenarioPartitions } = identity;
+	const dispatchRef = `improve:${evaluationRef}`;
 	const method = resolveOptimizationMethod(methodSource, {
 		profile,
 		evaluationRef,
 		surface,
 		baselineSurface,
-		baselineValue,
-		findings
+		baselineValue: prepared.baselineValue,
+		findings: prepared.findings,
+		searchIdentity: prepared.searchIdentity
 	});
 	const costScope = {
-		evaluationRef,
-		invocationId: runtimeInvocationId
+		evaluationRef: identity.evaluationRef,
+		invocationId
 	};
 	const invoke = async (current, input) => {
 		const controls = methodRuntimeControlsOf(current);
@@ -2025,7 +1976,7 @@ async function runMethodImprovement(profile, opts) {
 		}));
 		check(result.winnerSurface);
 		assertMethodCostRecorded(current.name, result, scopedInput.costLedger, invocationLedger, comparisonOptions.costCeiling, children > 0 ? "invocation" : controls?.costAttribution, [...historical.values()]);
-		if (controls?.costAttribution === "optimizer-run" && result.provenance?.runId) for (const receipt of methodHistoricalReceipts(scopedInput.costLedger, result.provenance.runId, runtimeInvocationId)) historical.set(receipt.callId, receipt);
+		if (controls?.costAttribution === "optimizer-run" && result.provenance?.runId) for (const receipt of methodHistoricalReceipts(scopedInput.costLedger, result.provenance.runId, invocationId)) historical.set(receipt.callId, receipt);
 		return {
 			result,
 			historical: [...historical.values()]
@@ -2038,13 +1989,15 @@ async function runMethodImprovement(profile, opts) {
 			return (await invoke(method, scopedInput)).result;
 		}
 	};
+	const methodStorage = optimizationRunOptions?.storage ?? comparisonOptions.storage ?? fsCampaignStorage();
 	const startedAt = Date.now();
 	const raw = await compareOptimizationMethods({
 		...comparisonOptions,
-		judges: identifiedJudges,
+		judges: prepared.judges,
 		dispatchRef,
 		optimizationRunOptions: {
 			...optimizationRunOptions ?? {},
+			storage: methodStorage,
 			dispatchRef
 		},
 		methods: [measuredMethod],
@@ -2052,16 +2005,19 @@ async function runMethodImprovement(profile, opts) {
 		dispatchWithSurface: (candidateSurface, scenario, ctx) => agent(materializeProfile(candidateSurface), scenario, ctx)
 	});
 	if (comparisonOptions.costCeiling !== void 0 && raw.totalCost.totalCostUsd > comparisonOptions.costCeiling) throw new ConfigError(`improve(): reported total cost $${raw.totalCost.totalCostUsd} exceeds costCeiling $${comparisonOptions.costCeiling}`);
+	const searchHistory = raw.searchHistory.producers[0]?.receipt ?? null;
+	if (searchHistory) {
+		if (!searchHistory.complete) throw new ConfigError(`improve(): method '${method.name}' returned an open search ledger: ${searchHistory.incompleteReasons.join("; ")}`);
+		verifySearchHistoryArtifact(searchHistory, methodStorage);
+	}
 	const score = raw.best;
 	const winnerSurface = immutableCandidateValue(score.winnerSurface);
 	assertCandidateSurfaceKind(surface, baselineSurface, winnerSurface);
-	const candidateProfile = materializeProfile(winnerSurface);
 	const candidate = Object.freeze({
 		surface,
 		value: winnerSurface,
-		profile: candidateProfile
+		profile: materializeProfile(winnerSurface)
 	});
-	const candidatePopulation = profileCandidatePopulation(score.provenance, profile, materializeProfile, winnerSurface, optimizationRunOptions?.storage);
 	const cost = copyImproveCost(raw.totalCost);
 	return {
 		mode: "method",
@@ -2071,23 +2027,501 @@ async function runMethodImprovement(profile, opts) {
 		decision: cost.accountingComplete && score.decision.promote && score.decision.low > minimumLift ? "ship" : "hold",
 		lift: score.lift,
 		liftInterval: { ...score.liftCi },
-		candidatePopulation,
+		searchHistory,
 		cost,
 		durationMs: Date.now() - startedAt,
 		lineage: Object.freeze({
-			invocationId: runtimeInvocationId,
-			runId: score.provenance?.runId ?? runtimeInvocationId,
+			invocationId,
+			runId: score.provenance?.runId ?? invocationId,
 			developmentSplitDigest,
 			finalTestSplitDigest,
 			scenarioPartitions,
-			executionRef,
-			baselineProfileDigest
+			executionRef: prepared.executionRef,
+			baselineProfileDigest: prepared.baselineProfileDigest
 		}),
 		raw,
 		async dispose() {}
 	};
 }
 //#endregion
+//#region src/improvement/search-method.ts
+/** Build Runtime's native search for `improve(profile, { method })`. */
+function searchMethod(options) {
+	if (!options || typeof options !== "object") throw new ConfigError("searchMethod(): options are required");
+	const { proposer } = options;
+	if (!proposer || typeof proposer.kind !== "string" || typeof proposer.propose !== "function") throw new ConfigError("searchMethod(): proposer must be a SurfaceProposer");
+	const count = (name, value, fallback, min) => {
+		const resolved = value ?? fallback;
+		if (!Number.isSafeInteger(resolved) || resolved < min) throw new ConfigError(`searchMethod(): ${name} must be an integer of at least ${min}`);
+		return resolved;
+	};
+	const dollars = (name, value) => {
+		if (value === void 0) return null;
+		if (!Number.isFinite(value) || value < 0) throw new ConfigError(`searchMethod(): ${name} must be a finite non-negative number`);
+		return value;
+	};
+	if (options.deadline !== void 0 && !Number.isFinite(Date.parse(options.deadline))) throw new ConfigError("searchMethod(): deadline must be an ISO time");
+	const name = options.name ?? "search";
+	if (!name.trim() || name.trim() !== name) throw new ConfigError("searchMethod(): name must be a trimmed non-empty string");
+	return Object.freeze({
+		kind: "search",
+		name,
+		policy: options.policy ?? incumbent(),
+		allocation: options.allocation ?? uniform(),
+		proposer,
+		maxExpansions: count("maxExpansions", options.maxExpansions, NaN, 0),
+		childrenPerProposal: count("childrenPerProposal", options.childrenPerProposal, 1, 1),
+		concurrency: count("concurrency", options.concurrency, 2, 1),
+		cellUsd: dollars("cellUsd", options.cellUsd) ?? 0,
+		claimReserveUsd: dollars("claimReserveUsd", options.claimReserveUsd),
+		deadline: options.deadline === void 0 ? null : new Date(options.deadline).toISOString(),
+		maxAttempts: count("maxAttempts", options.maxAttempts, 3, 1)
+	});
+}
+function isImproveSearchMethod(value) {
+	return typeof value === "object" && value !== null && value.kind === "search";
+}
+const SEARCH_METHOD_SOURCE = {
+	uri: "npm:@tangle-network/agent-runtime#searchMethod",
+	revision: canonicalCandidateDigest$1({
+		name: "agent-runtime.search-method.2026-09",
+		node: "an exact AgentProfile materialized from the baseline and one surface, content-addressed by canonicalAgentProfileDigest; a surface that does not materialize is a node addressed by its surface and refused",
+		edge: "the Interface diffs from the parent profile to the child, stored when they reproduce the child digest",
+		admission: "a candidate is refused when it does not materialize, declares training on a test task, fails the caller validator, or carries a credential or private value",
+		cell: "a one-cell runCampaign of the materialized profile in a directory addressed by its digest; a cached cell is read back, not run again",
+		proposer: "a SurfaceProposer reads the parents, the train view and the train summary; paid calls it makes are its operation accounting",
+		ship: "the claim shipped, re-derives from the ledger, cost accounting is complete, and the shipped finalist test lower bound exceeds minimumLift"
+	})
+};
+async function runSearchImprovement(profile, opts) {
+	const { method, claim: inputClaim, agent, 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, ...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 { allocation, policy } = method;
+	const reps = allocation.reps;
+	const prepared = prepareProfileImprovement(profile, {
+		...opts,
+		seed,
+		reps,
+		optimizationRunOptions: {
+			reps,
+			maxConcurrency: method.concurrency
+		}
+	});
+	const { evaluationRef } = prepared.identity;
+	const storage = campaignOptions.storage ?? fsCampaignStorage();
+	const runDir = resolveRunDir(campaignOptions.runDir, campaignOptions.repo);
+	const searchId = `improve-${canonicalCandidateDigest$1({
+		evaluationRef,
+		process: SEARCH_METHOD_SOURCE,
+		method: searchMethodDescriptor(method)
+	}).slice(7, 31)}`;
+	const searchDir = `${runDir}/search/${searchId}`;
+	const costLedger = inputCostLedger ?? createRunCostLedger({
+		storage,
+		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: method.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: method.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 codec = profileCodec(prepared);
+	const scenarios = [
+		...trainScenarios,
+		...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);
+	}
+	const lane = "in-process";
+	const executor = {
+		lanes: () => [{
+			name: lane,
+			capacity: method.concurrency,
+			costCap: "estimate",
+			cellUsd: method.cellUsd
+		}],
+		place: () => lane,
+		adopt: async () => null,
+		async run(work) {
+			const nodeProfile = work.artifact.profile;
+			if (!nodeProfile) throw new Error(`improve(): refused node ${work.nodeId} was given a cell`);
+			const profileDigest = canonicalAgentProfileDigest(nodeProfile);
+			const cell = (await runCampaign({
+				...campaignOptions,
+				scenarios,
+				judges: prepared.judges,
+				seed,
+				reps,
+				storage,
+				runDir: `${searchDir}/nodes/${profileDigest.slice(7)}`,
+				dispatchRef: `improve:${evaluationRef}:${profileDigest}`,
+				dispatch: (scenario, ctx) => agent(nodeProfile, scenario, ctx),
+				cellFilter: ({ scenario, rep }) => scenario.id === work.taskId && rep === work.rep,
+				resumable: true,
+				maxConcurrency: 1,
+				costLedger,
+				costPhase: `search.${work.stage}`,
+				signal: work.signal
+			})).cells[0];
+			if (!cell) throw new Error(`improve(): cell ${work.cellId} produced no campaign cell`);
+			return campaignCellSearchResult(cell, {
+				execution,
+				lane: work.lane
+			});
+		}
+	};
+	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
+		})
+	};
+	const proposalPhase = "search.proposal";
+	const port = {
+		name: proposer.kind,
+		kind: "optimizer",
+		source: proposerSource,
+		execution: {
+			kind: "deterministic",
+			source: proposerSource
+		},
+		childrenPerProposal: method.childrenPerProposal,
+		async propose(request) {
+			const before = new Set(costLedger.list({ phase: proposalPhase }).map((r) => r.callId));
+			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,
+				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 }).filter((receipt) => !before.has(receipt.callId));
+			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)
+			};
+		}
+	};
+	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 paths = privateValuePaths([node.surface]);
+		return paths.length === 0 ? null : `the surface carries a credential or private value at ${paths.slice(0, 8).join(", ")}`;
+	};
+	const startedAt = Date.now();
+	const result = await runSearch({
+		recorder,
+		root: nodeOf(prepared.baselineSurface),
+		codec,
+		policy,
+		allocation,
+		proposer: port,
+		executor,
+		admit,
+		maxExpansions: method.maxExpansions,
+		maxAttempts: method.maxAttempts,
+		...signal ? { signal } : {}
+	});
+	const { state } = result;
+	const claimResult = result.claim;
+	if (!claimResult || !result.claimVerification) throw new Error(`improve(): search ${searchId} closed without a claim`);
+	const kept = codec.load(recorder, state.node(result.leader));
+	if (!kept.profile) throw new Error(`improve(): search ${searchId} kept a refused node`);
+	const candidate = Object.freeze({
+		surface: prepared.surface,
+		value: kept.surface,
+		profile: kept.profile
+	});
+	const cost = copyImproveCost(costLedger.summary());
+	const shipped = claimResult.finalists.find((finalist) => finalist.nodeId === claimResult.selected && finalist.test !== null);
+	const { decision, reason } = runtimeShipDecision({
+		claim: claimResult,
+		verified: result.claimVerification.status === "verified",
+		accountingComplete: cost.accountingComplete,
+		lowerBound: shipped?.test?.interval[0] ?? null,
+		minimumLift: prepared.minimumLift
+	});
+	return {
+		mode: "search",
+		method: method.name,
+		candidate,
+		decision,
+		reason,
+		claim: claimResult,
+		claimVerification: result.claimVerification,
+		...shipped?.test ? {
+			lift: shipped.test.delta,
+			liftInterval: {
+				low: shipped.test.interval[0],
+				high: shipped.test.interval[1]
+			}
+		} : {},
+		searchHistory: recorder.receipt({
+			producerId: method.name,
+			runId: searchId
+		}),
+		cost,
+		durationMs: Date.now() - startedAt,
+		lineage: Object.freeze({
+			invocationId: prepared.invocationId,
+			runId: searchId,
+			developmentSplitDigest: prepared.identity.developmentSplitDigest,
+			finalTestSplitDigest: prepared.identity.finalTestSplitDigest,
+			scenarioPartitions: prepared.identity.scenarioPartitions,
+			executionRef: prepared.executionRef,
+			baselineProfileDigest: prepared.baselineProfileDigest
+		}),
+		async dispose() {}
+	};
+}
+/** Runtime's ship rule over the kernel's statistical claim (design §6.5 step 5). */
+function runtimeShipDecision(input) {
+	const { claim } = input;
+	if (claim.decision !== "ship") return {
+		decision: "hold",
+		reason: claim.reason
+	};
+	if (!input.verified) return {
+		decision: "hold",
+		reason: "the claim shipped, but it does not re-derive from the ledger under this rule revision"
+	};
+	if (!input.accountingComplete) return {
+		decision: "hold",
+		reason: "the claim shipped, but the search cost accounting is incomplete"
+	};
+	if (input.lowerBound === null || !(input.lowerBound > input.minimumLift)) return {
+		decision: "hold",
+		reason: `the claim shipped, but its test lower bound ${input.lowerBound} does not exceed minimumLift ${input.minimumLift}`
+	};
+	return {
+		decision: "ship",
+		reason: claim.reason
+	};
+}
+/** 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 {
+		name: method.name,
+		policy: method.policy.name,
+		allocation: method.allocation.name,
+		reps: method.allocation.reps,
+		proposer: method.proposer.kind,
+		maxExpansions: method.maxExpansions,
+		childrenPerProposal: method.childrenPerProposal,
+		concurrency: method.concurrency,
+		cellUsd: method.cellUsd,
+		claimReserveUsd: method.claimReserveUsd,
+		deadline: method.deadline,
+		maxAttempts: method.maxAttempts
+	};
+}
+/** 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) {
 	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`invalid ${label}`);
@@ -2472,7 +2906,9 @@ async function improve(profileOrCode, opts) {
 	if (opts.surface === "code") throw new ConfigError("improve(): code takes one argument: improve({ surface: 'code', ... })");
 	const parsedProfile = agentProfileSchema.safeParse(profileOrCode);
 	if (!parsedProfile.success) throw new ConfigError(`improve(): input is not a valid AgentProfile: ${parsedProfile.error.message}`);
-	return runMethodImprovement(immutableCandidateValue(parsedProfile.data), opts);
+	const exact = immutableCandidateValue(parsedProfile.data);
+	if (isImproveSearchMethod(opts.method)) return runSearchImprovement(exact, opts);
+	return runMethodImprovement(exact, opts);
 }
 //#endregion
 //#region src/intelligence/improvement-surfaces.ts
@@ -3704,6 +4140,6 @@ function sameOrderedValues(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 //#endregion
-export { agentImprovementTargetInput as A, assertCandidateValidator as B, optimizationActivationReceiptFromMetadata as C, agentImprovementProfileSurfaceDigest as D, agentImprovementProfileDiffs as E, isAgentImprovementProfileSurface as F, applyRolloutPolicyToProfile as G, parseExecutionRef as H, isAgentProfileMeasuredSurface as I, serializeRolloutPolicy as J, normalizeRolloutPolicy as K, improve as L, agentProfileImprovementStateDigest as M, assertProfileImprovementTargetsShareIdentity as N, agentImprovementProfileSurfaceInput as O, buildAgentImprovementActivationTargets as P, defaultBuildPrompt as Q, createCommandProfileTrainer as R, createOptimizationActivationReceipt as S, AGENT_PROFILE_MEASURED_SURFACES as T, rawTraceDistiller as U, assertProfileTrainingIsHeldOut as V, ROLLOUT_POLICY_EXTENSION as W, agenticGenerator as X, structuralRolloutPolicyFromProfile as Y, commandVerifier as Z, profilePolicyWithBudget as _, executeAgentCandidateExperimentCell as a, profileTaskScenarioIdentity as b, requireSealedCandidateExperiment as c, verifyAgentImprovementActivation as d, verifyAgentImprovementProposal as f, profileImprovementMetadata as g, createProfileImprovementCostLedger as h, createAgentImprovementProposal as i, agentImprovementTargetProfileDiffs as j, agentImprovementTargetDigest as k, reviewAgentImprovementProposal as l, verifyCandidateExecutionEvidence as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyAgentImprovementReview as p, parseRolloutPolicy as q, createAgentImprovementMeasuredComparison as r, proposeAgentProfileImprovement as s, AgentCandidateExperimentCellExecutionError as t, runAgentCandidateExperiment as u, profilePreparationAccounting as v, AGENT_IMPROVEMENT_PROFILE_SURFACES as w, sealProfileImprovementBenchmark as x, profileStateDigest as y, withMethodRuntimeControls as z };
+export { commandVerifier as $, agentImprovementTargetInput as A, assertCandidateValidator as B, optimizationActivationReceiptFromMetadata as C, agentImprovementProfileSurfaceDigest as D, agentImprovementProfileDiffs as E, isAgentImprovementProfileSurface as F, rawTraceDistiller as G, parseExecutionRef as H, isAgentProfileMeasuredSurface as I, normalizeRolloutPolicy as J, ROLLOUT_POLICY_EXTENSION as K, improve as L, agentProfileImprovementStateDigest as M, assertProfileImprovementTargetsShareIdentity as N, agentImprovementProfileSurfaceInput as O, buildAgentImprovementActivationTargets as P, agenticGenerator as Q, createCommandProfileTrainer as R, createOptimizationActivationReceipt as S, AGENT_PROFILE_MEASURED_SURFACES as T, privateValuePaths as U, assertProfileTrainingIsHeldOut as V, withMethodRuntimeControls as W, serializeRolloutPolicy as X, parseRolloutPolicy as Y, structuralRolloutPolicyFromProfile as Z, profilePolicyWithBudget as _, executeAgentCandidateExperimentCell as a, profileTaskScenarioIdentity as b, requireSealedCandidateExperiment as c, verifyAgentImprovementActivation as d, defaultBuildPrompt as et, verifyAgentImprovementProposal as f, profileImprovementMetadata as g, createProfileImprovementCostLedger as h, createAgentImprovementProposal as i, agentImprovementTargetProfileDiffs as j, agentImprovementTargetDigest as k, reviewAgentImprovementProposal as l, verifyCandidateExecutionEvidence as m, createAgentImprovementActivation as n, proposeAgentImprovement as o, verifyAgentImprovementReview as p, applyRolloutPolicyToProfile as q, createAgentImprovementMeasuredComparison as r, proposeAgentProfileImprovement as s, AgentCandidateExperimentCellExecutionError as t, runAgentCandidateExperiment as u, profilePreparationAccounting as v, AGENT_IMPROVEMENT_PROFILE_SURFACES as w, sealProfileImprovementBenchmark as x, profileStateDigest as y, searchMethod as z };
 
-//# sourceMappingURL=improvement-cycle-DQyN0__A.js.map
+//# sourceMappingURL=improvement-cycle-Bi43xCVa.js.map