@tangle-network/agent-runtime 0.301.0 → 0.306.1

package/dist/{improvement-cycle-Cf37Kexd.js → improvement-cycle-DsN-TVXR.js}

@@ -1,23 +1,25 @@
-import { Mt as createExecutor, Tr as runAbortable, mi as terminateProcessTreeAndConfirm, na as detachedSnapshot, ni as runSettledCommand, wr as linkAbort, za as armDeadlineTimer } from "./supervisor-DA_nvF-h.js";
+import { Bi as detachedSnapshot, Wr as runSettledCommand, fr as linkAbort, ni as terminateProcessTreeAndConfirm, pr as runAbortable, xt as createExecutor } from "./supervisor-gCfG6K1-.js";
 import { i as ConfigError } from "./errors-DodWX-cb.js";
-import { D as ROLLOUT_POLICY_EXTENSION, E as isCodeSurface, M as structuralRolloutPolicyFromProfile, S as parseExecutionRef, T as assertCandidateSurfaceKind, b as assertCandidateValidator, lt as collectAgentTurn, n as runSearchImprovement, ot as copyImproveCost, st as optimizerMethod, t as isImproveSearchMethod, ut as streamAgentTurn, w as validateProfileCandidate, x as assertProfileTrainingIsHeldOut, y as prepareProfileImprovement } from "./search-method-wTTS7mGG.js";
+import { E as defaultStructuralRolloutPolicy, Q as streamAgentTurn, Y as optimizerMethod, Z as collectAgentTurn, 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-2tWr38Qw.js";
+import { A as canonicalCandidateBytes$1, F as immutableCandidateValue, I as omitTopLevelDigest, L as sha256Bytes$1, M as canonicalCandidateDocument, R as verifyCanonicalCandidateDocument, _t as armDeadlineTimer, j as canonicalCandidateDigest$1 } from "./workspace-streams-ILw0eWZ0.js";
 import { a as concreteProfileModel, t as assertExecutableAgentProfile } from "./model-policy-DydyWTQg.js";
-import { A as canonicalCandidateDocument, F as sha256Bytes$1, I as verifyCanonicalCandidateDocument, N as immutableCandidateValue, O as canonicalCandidateBytes$1, P as omitTopLevelDigest, k as canonicalCandidateDigest$1 } from "./workspace-streams-D5gHJdTb.js";
 import { i as syncDurableDirectory, r as publishExclusiveDurableFile } from "./durable-file-DWQA4ooo.js";
 import { t as runAnalystLoop } from "./analyst-loop-DZw5QWT9.js";
-import { c as executePreparedAgentCandidate, o as verifiedResourceTextByDigest, s as verifyAgentCandidateBundle, t as prepareAgentCandidateExecution } from "./prepare-CGVNMb1o.js";
-import { a as assertCandidateProfileBinding, c as createAgentCandidateProfileActivation, d as omitUndefinedObjectFields, f as parseAgentCandidateProfileActivation, i as applyExactAgentProfileDiff, p as parseExactAgentProfile, r as agentCandidateProfileAsAgentProfile, u as materializeAgentCandidateProfilePlan } from "./profile-BetOB4_Q.js";
-import { AGENT_IMPROVEMENT_SOURCE_METADATA_KEY, agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentImprovementSourceMetadata, agentImprovementSourceSchema, agentProfileDiffSchema, agentProfileEnvironmentSchema, agentProfileImprovementArmSchema, agentProfileImprovementExecutionRefSchema, agentProfileModelHintsSchema, agentProfileSchema, agentProfileTrainingSchema, agentTrainingDatasetIdentitySchema, agentTrainingParametersSchema, agentTrainingReceiptSchema, agentTrainingTaskKey, agentTrainingTaskSchema, candidateExecutionEvidenceSchema, canonicalAgentProfileDigest, canonicalCandidateBytes, changedProfileImprovementSurfaces, defineAgentProfileDiff, numbersApproximatelyEqual, sha256DigestSchema, snapshotAgentProfile, trainedModelIdForArtifact } from "@tangle-network/agent-interface";
-import { CostLedger, makeProposalFinding } from "@tangle-network/agent-eval";
+import { c as executePreparedAgentCandidate, o as verifiedResourceTextByDigest, s as verifyAgentCandidateBundle, t as prepareAgentCandidateExecution } from "./prepare--nWcazPr.js";
+import { a as assertCandidateProfileBinding, c as createAgentCandidateProfileActivation, d as omitUndefinedObjectFields, f as parseAgentCandidateProfileActivation, i as applyExactAgentProfileDiff, p as parseExactAgentProfile, r as agentCandidateProfileAsAgentProfile, u as materializeAgentCandidateProfilePlan } from "./profile-h04LDjV6.js";
+import { AGENT_IMPROVEMENT_SOURCE_METADATA_KEY, agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, agentImprovementActivationSchema, agentImprovementProposalSchema, agentImprovementReviewSchema, agentImprovementSourceMetadata, agentImprovementSourceSchema, agentProfileDiffSchema, agentProfileEnvironmentSchema, agentProfileImprovementArmSchema, agentProfileImprovementExecutionRefSchema, agentProfileModelHintsSchema, agentProfileSchema, agentProfileTrainingSchema, agentTrainingDatasetIdentitySchema, agentTrainingParametersSchema, agentTrainingReceiptSchema, agentTrainingTaskKey, agentTrainingTaskSchema, applyAgentProfileDiff, candidateExecutionEvidenceSchema, canonicalAgentProfileDigest, canonicalCandidateBytes, changedProfileImprovementSurfaces, defineAgentProfileDiff, diffAgentProfiles, numbersApproximatelyEqual, sha256DigestSchema, snapshotAgentProfile, trainedModelIdForArtifact } from "@tangle-network/agent-interface";
+import { CostLedger, canonicalJson, makeProposalFinding } from "@tangle-network/agent-eval";
 import { createHash, randomUUID } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import { constants, existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
 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 { redact } from "@tangle-network/agent-eval/traces";
 import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
-import { campaignSplitDigestFromIdentities, compareOptimizationMethods, fsCampaignStorage, gitWorktreeAdapter, verifyCodeSurface, verifySearchHistoryArtifact } from "@tangle-network/agent-eval/campaign";
+import { SearchRecorder, aide, asha, campaignCellSearchResult, campaignScenarioIdentity, campaignSplitDigestFromIdentities, compareOptimizationMethods, createRunCostLedger, fsCampaignStorage, gitWorktreeAdapter, isProposedCandidate, openSearchLedger, renderSearchSummary, resolveRunDir, runCampaign, runSearch, searchClaimReserveUsd, searchNodeId, searchProposalExecution, searchProposerView, searchReceiptAccounting, 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.
@@ -686,6 +688,15 @@ async function rethrowAfterCleanup(cause, cleanup, context) {
 	throw new AggregateError([cause, ...cleanupErrors], `${context}; cleanup failed`);
 }
 //#endregion
+//#region src/improvement/improve-result.ts
+function copyImproveCost(cost) {
+	return {
+		totalCostUsd: cost.totalCostUsd,
+		accountingComplete: cost.accountingComplete,
+		incompleteReasons: [...cost.incompleteReasons]
+	};
+}
+//#endregion
 //#region src/improvement/improvement-driver.ts
 /**
 * Code-only candidate driver for Runtime-owned git worktrees.
@@ -798,6 +809,334 @@ function advanceToIncumbent(worktree, incumbent) {
 	if (head.error || head.status !== 0 || head.stdout.trim() !== incumbent.candidateCommit) throw new Error("improvementDriver: candidate worktree did not reach the incumbent commit");
 }
 //#endregion
+//#region src/improvement/rollout-policy.ts
+/** The profile extensions namespace the policy persists under. */
+const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
+const isBoundedInt = (v, min) => typeof v === "number" && Number.isInteger(v) && v >= min;
+/** Parse a serialized policy surface. Returns `undefined` for non-strings,
+* malformed JSON, or values outside the policy invariants. Unknown fields are
+* dropped; supported optional fields are preserved. */
+function parseRolloutPolicy(surface) {
+	if (typeof surface !== "string" || surface.trim().length === 0) return void 0;
+	let raw;
+	try {
+		raw = JSON.parse(surface);
+	} catch {
+		return;
+	}
+	return normalizeRolloutPolicy(raw);
+}
+/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
+*  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
+*  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
+*  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
+*  configured", never as a fabricated recipe. */
+function normalizeRolloutPolicy(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const bag = raw;
+	const k = bag.k ?? defaultStructuralRolloutPolicy.k;
+	const repairRounds = bag.repairRounds ?? defaultStructuralRolloutPolicy.repairRounds;
+	const testgen = bag.testgen ?? defaultStructuralRolloutPolicy.testgen;
+	if (!isBoundedInt(k, 1) || !isBoundedInt(repairRounds, 0) || !isBoundedInt(testgen, 0)) return;
+	return {
+		k,
+		repairRounds,
+		testgen,
+		...typeof bag.diverse === "boolean" ? { diverse: bag.diverse } : {}
+	};
+}
+/** Stable serialization with fixed field order. */
+function serializeRolloutPolicy(policy) {
+	return JSON.stringify({
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {}
+	});
+}
+/** Read the persisted policy off the profile. `undefined` when the profile does
+*  not opt into structural rollout. */
+function structuralRolloutPolicyFromProfile(profile) {
+	const bag = profile.extensions?.[ROLLOUT_POLICY_EXTENSION];
+	if (bag === void 0) return void 0;
+	return normalizeRolloutPolicy(bag);
+}
+/** Persist a detached policy under the profile extension without mutating the input. */
+function applyRolloutPolicyToProfile(profile, policy) {
+	const candidate = structuredClone(profile);
+	const bag = {
+		k: policy.k,
+		repairRounds: policy.repairRounds,
+		testgen: policy.testgen,
+		...policy.diverse !== void 0 ? { diverse: policy.diverse } : {}
+	};
+	return {
+		...candidate,
+		extensions: {
+			...candidate.extensions,
+			[ROLLOUT_POLICY_EXTENSION]: bag
+		}
+	};
+}
+//#endregion
+//#region src/improvement/profile-surface.ts
+/** Extract the baseline optimized by a method and retain its structured value
+* so external optimizers can inspect it for private fields before serialization. */
+function prepareProfileSurface(profile, surface, skills, profileComponents) {
+	switch (surface) {
+		case "prompt": return {
+			surface: profile.prompt?.systemPrompt ?? "",
+			value: profile.prompt?.systemPrompt ?? ""
+		};
+		case "skills": {
+			const value = inlineSkill(profile, skills).content;
+			return {
+				surface: value,
+				value
+			};
+		}
+		case "tools": {
+			const value = profile.tools ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "mcp": {
+			const value = profile.mcp ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "hooks": {
+			const value = profile.hooks ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "subagents": {
+			const value = profile.subagents ?? {};
+			return {
+				surface: canonicalJson(value),
+				value
+			};
+		}
+		case "agent-profile":
+			if (profileComponents) {
+				if (profileComponents.encoding !== void 0 && profileComponents.encoding !== "components" && profileComponents.encoding !== "json") throw new ConfigError("improve(): profileComponents.encoding must be components or json");
+				const value = profileComponents.read(profile);
+				const components = componentSurface(value, "profileComponents.read");
+				return {
+					surface: profileComponents.encoding === "json" ? canonicalJson(components.components) : components,
+					value
+				};
+			}
+			return {
+				surface: canonicalJson(profile),
+				value: profile
+			};
+		case "memory": {
+			const value = profileInstructions(profile);
+			return {
+				surface: value,
+				value
+			};
+		}
+		case "rollout-policy": {
+			const policy = structuralRolloutPolicyFromProfile(profile);
+			return {
+				surface: policy ? serializeRolloutPolicy(policy) : "",
+				value: policy ?? null
+			};
+		}
+		case "code": throw new ConfigError("improve(): code requires the isolated baseline created from opts.code.repoRoot");
+	}
+}
+function isCodeSurface(surface) {
+	return typeof surface === "object" && surface !== null && surface.kind === "code";
+}
+function isComponentSurface(surface) {
+	return typeof surface === "object" && surface !== null && surface.kind === "components";
+}
+function componentSurface(components, source) {
+	const entries = validateComponents(components, source);
+	return immutableCandidateValue({
+		kind: "components",
+		components: Object.fromEntries(entries)
+	});
+}
+function validateComponents(components, source) {
+	if (typeof components !== "object" || components === null || Array.isArray(components)) throw new ConfigError(`improve(): ${source} must return a component record`);
+	const entries = Object.entries(components);
+	if (entries.length === 0) throw new ConfigError(`improve(): ${source} must return at least one component`);
+	for (const [name, value] of entries) if (!name || name.trim() !== name || typeof value !== "string") throw new ConfigError(`improve(): ${source} must return trimmed component names with string values`);
+	return entries;
+}
+/** Parse a JSON winner surface with a typed, contextual error. */
+function parseWinnerJson(winner, surface) {
+	try {
+		return JSON.parse(winner);
+	} catch (cause) {
+		throw new ConfigError(`improve(): the '${surface}' candidate is not valid JSON, so it cannot form a profile candidate: ${cause.message}`);
+	}
+}
+function assertCandidateSurfaceKind(surface, baseline, winner) {
+	if (surface === "code") {
+		if (isCodeSurface(winner)) return;
+		throw new ConfigError(`improve(): the '${surface}' candidate returned an incompatible surface value`);
+	}
+	if (typeof baseline === "string") {
+		if (typeof winner === "string") return;
+		throw new ConfigError(`improve(): the '${surface}' candidate changed from a text surface to an incompatible surface value`);
+	}
+	if (!isComponentSurface(baseline) || !isComponentSurface(winner)) throw new ConfigError(`improve(): the '${surface}' candidate returned an incompatible surface value`);
+	validateComponents(winner.components, `the '${surface}' candidate`);
+	const baselineNames = Object.keys(baseline.components).sort();
+	const winnerNames = Object.keys(winner.components).sort();
+	if (baselineNames.length !== winnerNames.length || baselineNames.some((name, index) => name !== winnerNames[index])) throw new ConfigError(`improve(): the '${surface}' candidate must preserve the exact component names`);
+}
+/** Materialize a detached profile candidate without changing the baseline. */
+function materializeImprovementProfileCandidate(profile, surface, winner, skills, profileComponents) {
+	let candidate;
+	if (isComponentSurface(winner)) {
+		if (surface !== "agent-profile" || !profileComponents) throw new ConfigError(`improve(): the '${surface}' candidate has no profile component mapping`);
+		const winnerComponents = immutableCandidateValue({ ...winner.components });
+		const validated = parseMaterializedProfile(profileComponents.apply(profile, winnerComponents), surface);
+		const materializedComponents = Object.fromEntries(validateComponents(profileComponents.read(validated), "profileComponents.read after apply"));
+		const names = Object.keys(winnerComponents);
+		if (names.length !== Object.keys(materializedComponents).length || names.some((name) => materializedComponents[name] !== winnerComponents[name])) throw new ConfigError("improve(): profileComponents.apply must round-trip every winning component exactly");
+		return validated;
+	}
+	if (typeof winner !== "string") throw new ConfigError(`improve(): the '${surface}' candidate cannot form an AgentProfile`);
+	switch (surface) {
+		case "prompt":
+			candidate = {
+				...profile,
+				prompt: {
+					...profile.prompt,
+					systemPrompt: winner
+				}
+			};
+			break;
+		case "skills": {
+			const selectedSkill = inlineSkill(profile, skills);
+			candidate = {
+				...profile,
+				resources: {
+					...profile.resources,
+					skills: profile.resources?.skills?.map((resource) => resource === selectedSkill ? {
+						...resource,
+						content: winner
+					} : resource)
+				}
+			};
+			break;
+		}
+		case "tools":
+			candidate = {
+				...profile,
+				tools: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "mcp":
+			candidate = {
+				...profile,
+				mcp: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "hooks":
+			candidate = {
+				...profile,
+				hooks: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "subagents":
+			candidate = {
+				...profile,
+				subagents: parseWinnerJson(winner, surface)
+			};
+			break;
+		case "agent-profile":
+			candidate = parseWinnerJson(winner, surface);
+			break;
+		case "memory":
+			candidate = {
+				...profile,
+				resources: {
+					...profile.resources,
+					instructions: replaceProfileInstructions(profile, winner)
+				}
+			};
+			break;
+		case "rollout-policy": {
+			const policy = normalizeRolloutPolicy(parseWinnerJson(winner, surface));
+			if (!policy) throw new ConfigError(`improve(): the shipped 'rollout-policy' winner is not a valid StructuralRolloutPolicy (integer k >= 1, repairRounds >= 0, testgen >= 0), so it cannot be applied: ${winner}`);
+			candidate = applyRolloutPolicyToProfile(profile, policy);
+			break;
+		}
+	}
+	return parseMaterializedProfile(candidate, surface);
+}
+function parseMaterializedProfile(candidate, surface) {
+	const parsed = agentProfileSchema.safeParse(candidate);
+	if (!parsed.success) throw new ConfigError(`improve(): the '${surface}' candidate does not produce a valid AgentProfile: ${parsed.error.message}`);
+	return immutableCandidateValue(parsed.data);
+}
+function createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents) {
+	const decode = (candidate) => {
+		if (profileComponents?.encoding !== "json") return candidate;
+		if (typeof candidate !== "string") throw new ConfigError("improve(): JSON profile components require a text surface");
+		return componentSurface(parseWinnerJson(candidate, surface), "JSON profile components");
+	};
+	const decodedBaseline = decode(baselineSurface);
+	const baselineDigest = canonicalCandidateDigest$1(baselineSurface);
+	if (profileComponents) {
+		if (canonicalAgentProfileDigest(materializeImprovementProfileCandidate(profile, surface, decodedBaseline, skills, profileComponents)) !== canonicalAgentProfileDigest(profile)) throw new ConfigError("improve(): profileComponents.apply(profile, profileComponents.read(profile)) must reproduce the complete baseline profile exactly");
+	}
+	const candidates = /* @__PURE__ */ new Map([[baselineDigest, profile]]);
+	return (candidateSurface) => {
+		assertCandidateSurfaceKind(surface, baselineSurface, candidateSurface);
+		const decodedCandidate = decode(candidateSurface);
+		assertCandidateSurfaceKind(surface, decodedBaseline, decodedCandidate);
+		const digest = canonicalCandidateDigest$1(candidateSurface);
+		const existing = candidates.get(digest);
+		if (existing) return existing;
+		const candidate = materializeImprovementProfileCandidate(profile, surface, immutableCandidateValue(decodedCandidate), skills, profileComponents);
+		candidates.set(digest, candidate);
+		return candidate;
+	};
+}
+function inlineSkill(profile, options) {
+	const resourceName = options?.resourceName.trim();
+	if (!resourceName) throw new ConfigError("improve(): surface 'skills' requires opts.skills.resourceName for one inline profile skill");
+	assertFailClosedResources(profile, "skills");
+	const matches = (profile.resources?.skills ?? []).filter((resource) => resource.name === resourceName);
+	if (matches.length !== 1 || matches[0]?.kind !== "inline") throw new ConfigError(`improve(): skill '${resourceName}' must identify exactly one inline profile resource`);
+	return matches[0];
+}
+function profileInstructions(profile) {
+	assertFailClosedResources(profile, "memory");
+	const instructions = profile.resources?.instructions;
+	if (instructions === void 0) return "";
+	if (typeof instructions === "string") return instructions;
+	if (instructions.kind === "inline") return instructions.content;
+	throw new ConfigError("improve(): surface 'memory' requires inline profile instructions so candidate bytes are exact");
+}
+function replaceProfileInstructions(profile, content) {
+	const instructions = profile.resources?.instructions;
+	if (typeof instructions !== "object") return content;
+	if (instructions.kind !== "inline") throw new ConfigError("improve(): surface 'memory' requires inline profile instructions so candidate bytes are exact");
+	return {
+		...instructions,
+		content
+	};
+}
+function assertFailClosedResources(profile, surface) {
+	if (profile.resources?.failOnError !== true) throw new ConfigError(`improve(): surface '${surface}' requires profile.resources.failOnError: true`);
+}
+//#endregion
 //#region src/improvement/raw-trace-distiller.ts
 /**
 *
@@ -1342,6 +1681,233 @@ 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;
+	const finalTestReps = input.reps ?? 1;
+	const scenarioPartitions = immutableCandidateValue({
+		train: input.trainScenarios.map(campaignScenarioIdentity),
+		selection: input.selectionScenarios.map(campaignScenarioIdentity),
+		finalTest: input.testScenarios.map(campaignScenarioIdentity),
+		optimizationReps,
+		finalTestReps
+	});
+	const developmentSplitDigest = canonicalCandidateDigest$1({
+		train: campaignSplitDigestFromIdentities(scenarioPartitions.train, optimizationReps),
+		selection: campaignSplitDigestFromIdentities(scenarioPartitions.selection, optimizationReps)
+	});
+	const finalTestSplitDigest = campaignSplitDigestFromIdentities(scenarioPartitions.finalTest, finalTestReps);
+	const judgeDescriptors = input.judges.map(judgeDescriptor);
+	return {
+		evaluationRef: canonicalCandidateDigest$1({
+			executionRef: input.executionRef,
+			baselineProfileDigest: input.baselineProfileDigest,
+			coordinate: profileCoordinate(input.surface, input.baselineSurface, input.skills),
+			candidateValidation: input.validateCandidate ? Function.prototype.toString.call(input.validateCandidate) : null,
+			developmentSplitDigest,
+			finalTestSplitDigest,
+			findings: input.findings,
+			judges: judgeDescriptors,
+			run: {
+				seed: input.seed ?? 42,
+				finalReps: input.reps ?? 1,
+				optimizationReps,
+				costCeiling: input.costCeiling ?? null,
+				resumable: input.optimizationRunOptions?.resumable ?? true,
+				maxConcurrency: input.optimizationRunOptions?.maxConcurrency ?? 2,
+				abortOnCellError: input.optimizationRunOptions?.abortOnCellError ?? false,
+				dispatchTimeoutMs: input.optimizationRunOptions?.dispatchTimeoutMs ?? null,
+				dispatchShutdownTimeoutMs: input.optimizationRunOptions?.dispatchShutdownTimeoutMs ?? 5e3,
+				tracing: input.optimizationRunOptions?.tracing ?? "on",
+				expectUsage: input.optimizationRunOptions?.expectUsage ?? "warn",
+				captureSource: input.optimizationRunOptions?.captureSource ?? null,
+				captureSourceVersionHash: input.optimizationRunOptions?.captureSourceVersionHash ?? null
+			}
+		}),
+		developmentSplitDigest,
+		finalTestSplitDigest,
+		scenarioPartitions,
+		judgeDescriptors
+	};
+}
+function profileCoordinate(surface, baselineSurface, skills) {
+	return {
+		surface,
+		resourceName: surface === "skills" ? skills?.resourceName.trim() ?? null : null,
+		componentNames: typeof baselineSurface === "object" && baselineSurface !== null && baselineSurface.kind === "components" ? Object.keys(baselineSurface.components).sort() : []
+	};
+}
+function judgeDescriptor(judge) {
+	return {
+		name: judge.name,
+		dimensions: judge.dimensions.map((dimension) => ({ ...dimension })),
+		declaredVersion: judge.judgeVersion ?? null,
+		scoreImplementation: Function.prototype.toString.call(judge.score),
+		appliesToImplementation: judge.appliesTo ? Function.prototype.toString.call(judge.appliesTo) : null
+	};
+}
+//#endregion
+//#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'");
+	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);
+	const baselineProfileDigest = canonicalAgentProfileDigest(profile);
+	const identity = buildMethodEvaluationIdentity({
+		executionRef,
+		baselineProfileDigest,
+		baselineSurface,
+		surface,
+		skills,
+		validateCandidate,
+		findings,
+		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 judges = input.judges.map((judge, index) => Object.freeze({
+		...judge,
+		judgeVersion: canonicalCandidateDigest$1({
+			evaluationRef: identity.evaluationRef,
+			descriptor: identity.judgeDescriptors[index]
+		})
+	}));
+	const rawMaterializeProfile = createProfileCandidateMaterializer(profile, surface, baselineSurface, skills, profileComponents);
+	const baselineSurfaceDigest = canonicalCandidateDigest$1(baselineSurface);
+	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);
+		validateProfileCandidate(validator, {
+			profile: candidate,
+			surface,
+			candidateSurface,
+			value: immutableCandidateValue(prepared.value),
+			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);
+		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;
@@ -1478,6 +2044,559 @@ async function runMethodImprovement(profile, opts) {
 	};
 }
 //#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");
+	assertSearchLanes(options.lanes, "searchMethod()");
+	return Object.freeze({
+		kind: "search",
+		name,
+		policy: options.policy ?? aide(),
+		allocation: options.allocation ?? asha(),
+		proposer,
+		maxExpansions: count("maxExpansions", options.maxExpansions, NaN, 0),
+		childrenPerProposal: count("childrenPerProposal", options.childrenPerProposal, 1, 1),
+		lanes: Object.freeze([...options.lanes]),
+		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, carries a credential or private value, or no lane can run its profile",
+		cell: "a one-cell runCampaign of the materialized profile in a directory addressed by its digest, on a lane that accepts the profile; a cached cell is read back, not run again; a finished attempt is recorded by run id before it settles and adopted after a restart",
+		lanes: "a hard lane refuses a paid call that declares no priced maximum or would take the cell past its cellUsd; an environment fault settles errored and retryable; a subscription seat reports no tokens and charges no dollars",
+		proposer: "a SurfaceProposer reads the parents, the train view and the train summary; paid calls it makes are its operation accounting"
+	})
+};
+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 { allocation, policy, lanes } = method;
+	const reps = allocation.reps;
+	const concurrency = lanes.reduce((total, lane) => total + lane.capacity, 0);
+	const prepared = prepareProfileImprovement(profile, {
+		...opts,
+		seed,
+		reps,
+		optimizationRunOptions: {
+			reps,
+			maxConcurrency: 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: 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 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;
+		}
+	};
+	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);
+	if (root.profile) {
+		const refused = laneRefusal(root.profile);
+		if (refused) throw new ConfigError(`improve(): the baseline profile cannot run: ${refused}`);
+	}
+	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 executor = searchExecutor({
+		lanes,
+		profileOf(nodeId) {
+			const known = profiles.get(nodeId);
+			if (known === void 0) throw new Error(`improve(): node ${nodeId} was placed unregistered`);
+			return known;
+		},
+		costLedger,
+		identity: execution,
+		storage,
+		dir: searchDir,
+		...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
+		})
+	};
+	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 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)
+			};
+		}
+	};
+	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]);
+		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 } : {}
+	});
+	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 = improveSearchCost(costLedger);
+	const decided = await decideClosedSearch({
+		state,
+		claim: claimResult,
+		claimVerification: result.claimVerification,
+		cost,
+		costCeiling,
+		minimumLift: prepared.minimumLift,
+		profileOf(nodeId) {
+			const node = state.node(nodeId);
+			const loaded = node ? codec.load(recorder, node) : null;
+			if (!loaded?.profile) throw new Error(`improve(): search ${searchId} node ${nodeId} holds no profile`);
+			return loaded.profile;
+		}
+	});
+	return {
+		mode: "search",
+		method: method.name,
+		candidate,
+		...decided,
+		claim: claimResult,
+		claimVerification: result.claimVerification,
+		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() {}
+	};
+}
+/** 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,
+		lanes: method.lanes.map(({ name, kind, capacity, costCap, cellUsd }) => ({
+			name,
+			kind,
+			capacity,
+			costCap,
+			cellUsd
+		})),
+		claimReserveUsd: method.claimReserveUsd,
+		deadline: method.deadline,
+		maxAttempts: method.maxAttempts
+	};
+}
+/**
+* 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.
+*/
+function faultResult(result, fault) {
+	if (fault === void 0 || result.outcome.status !== "errored") return result;
+	return {
+		...result,
+		outcome: {
+			...result.outcome,
+			error: {
+				code: "environment-fault",
+				message: refusalText(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) {
 	if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`invalid ${label}`);
@@ -3096,6 +4215,6 @@ function sameOrderedValues(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 //#endregion
-export { agentImprovementTargetInput as A, rawTraceDistiller as B, optimizationActivationReceiptFromMetadata as C, agentImprovementProfileSurfaceDigest as D, agentImprovementProfileDiffs as E, isAgentImprovementProfileSurface as F, commandVerifier as H, isAgentProfileMeasuredSurface as I, improve as L, agentProfileImprovementStateDigest as M, assertProfileImprovementTargetsShareIdentity as N, agentImprovementProfileSurfaceInput as O, buildAgentImprovementActivationTargets as P, createCommandProfileTrainer as R, createOptimizationActivationReceipt as S, AGENT_PROFILE_MEASURED_SURFACES as T, defaultBuildPrompt as U, agenticGenerator as V, 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, 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-Cf37Kexd.js.map
+//# sourceMappingURL=improvement-cycle-DsN-TVXR.js.map