@tangle-network/agent-runtime 0.300.0 → 0.306.1

package/dist/{search-method-DvU-fc-f.js → search-executor-2tWr38Qw.js}

@@ -1,19 +1,18 @@
-import { At as createExecutor, Ba as promptFromAgentTurnInput, Bn as InMemoryResultBlobStore, Ca as sleep, Dt as captureReusableExecutorConfig, En as LEAF_CONTINUATION_TASK, Fa as awaitAbortable, Fi as authoredProfileDigest, Gi as runtimeOwnedExecutorMaterialization, Ha as providerMessageText, Hr as createOtelExporter, Jr as toOtelAttributes, Kr as padSpanId, La as armDeadlineTimer, M as withDriverExecutor, Mn as unavailableSignalOfFailure, Ri as knownExecutionBindingReceipt, Va as promptOptionsFromAgentTurnInput, Vn as InMemorySpawnJournal, Vr as createOpenInferenceFileExporter, Wi as runtimeOwnedExecutorExecutionBinding, Wr as generateSpanId, Xi as unknownMaterializationReceipt, Yi as unknownExecutionBindingReceipt, Zi as executableAgentProfileSnapshot, aa as createSandboxToolPartState, ca as isSandboxTerminalEvent, ia as canonicalStreamEventFromSandboxEvent, jn as unavailablePauseMs, jt as createExecutorRegistry, la as mapSandboxEvent, na as readSandboxOutcome, oa as createSandboxUsageLedger, qi as runtimeOwnedPendingExecutorMaterialization, qr as padTraceId, r as createSupervisor, si as harnessInvocation, ta as projectSandboxOutcome, ua as mapSandboxToolEvent, yr as openSlotGroup, zi as knownMaterializationReceipt } from "./supervisor-CQSu5XGl.js";
+import { Ai as runtimeOwnedExecutorExecutionBinding, Fi as unknownExecutionBindingReceipt, Gi as createSandboxToolPartState, Hi as readSandboxOutcome, Ii as unknownMaterializationReceipt, Ir as padSpanId, Ji as isSandboxTerminalEvent, Ki as createSandboxUsageLedger, Li as executableAgentProfileSnapshot, Lr as padTraceId, Mr as createOtelExporter, Ni as runtimeOwnedPendingExecutorMaterialization, On as InMemoryResultBlobStore, Pr as generateSpanId, Rr as toOtelAttributes, St as createExecutorRegistry, Ti as knownMaterializationReceipt, Vi as projectSandboxOutcome, Wi as canonicalStreamEventFromSandboxEvent, Xi as mapSandboxToolEvent, Yi as mapSandboxEvent, Zr as harnessInvocation, aa as promptOptionsFromAgentTurnInput, bn as unavailableSignalOfFailure, ia as promptFromAgentTurnInput, j as withDriverExecutor, ji as runtimeOwnedExecutorMaterialization, jr as createOpenInferenceFileExporter, kn as InMemorySpawnJournal, lr as openSlotGroup, mn as LEAF_CONTINUATION_TASK, oa as providerMessageText, r as createSupervisor, ra as awaitAbortable, vt as captureReusableExecutorConfig, wi as knownExecutionBindingReceipt, xi as authoredProfileDigest, xt as createExecutor, yn as unavailablePauseMs } from "./supervisor-gCfG6K1-.js";
 import { i as ConfigError, m as ValidationError, p as SessionMismatchError, r as BackendTransportError } from "./errors-DodWX-cb.js";
+import { F as immutableCandidateValue, G as errorMessage$1, Y as isAsyncIterable, _t as armDeadlineTimer, tt as sleep } from "./workspace-streams-ILw0eWZ0.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, g as observedModelMatchesDeclared, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile } from "./model-policy-DydyWTQg.js";
-import { N as immutableCandidateValue, k as canonicalCandidateDigest$1 } from "./workspace-streams-D5gHJdTb.js";
-import { agentProfileSchema, applyAgentProfileDiff, canonicalAgentProfileDigest, canonicalCandidateDigest, diffAgentProfiles, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
-import { CostAccountingIncompleteError, CostCeilingReachedError, canonicalJson, costForTokenPricing, costForUsage, makeProposalFinding, scoreKnowledgeReadiness } from "@tangle-network/agent-eval";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, renderInputPartsAsText } from "@tangle-network/agent-interface";
+import { CostAccountingIncompleteError, CostCeilingReachedError, costForTokenPricing, costForUsage, makeProposalFinding, scoreKnowledgeReadiness } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
-import { randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { materializeProfile } from "@tangle-network/agent-profile-materialize";
 import { ATTR, branchSpan } from "@tangle-network/agent-trace-contract";
-import { redact } from "@tangle-network/agent-eval/traces";
 import { assertProposalFindings } from "@tangle-network/agent-eval/analyst";
-import { SearchRecorder, aide, asha, campaignCellSearchResult, campaignScenarioIdentity, campaignSplitDigestFromIdentities, createRunCostLedger, fsCampaignStorage, isProposedCandidate, openSearchLedger, renderSearchSummary, resolveRunDir, runCampaign, runSearch, searchClaimReserveUsd, searchNodeId, searchProposalExecution, searchProposerView, searchReceiptAccounting } from "@tangle-network/agent-eval/campaign";
-import { defineEvaluationClaim, summarizeEvaluationUnits } from "@tangle-network/agent-eval/experiment";
+import { createRunCostLedger, fsCampaignStorage, openSearchLedger, searchClaimDecision, searchReceiptAccounting, verifySearchClaim } from "@tangle-network/agent-eval/campaign";
+import { sealExperiment } from "@tangle-network/agent-eval/experiment";
 import { harnessSystemPromptIntents } from "@tangle-network/agent-interface/harness-capabilities";
 //#region src/sessions.ts
 /**
@@ -817,9 +816,6 @@ function executorTaskValue(input) {
 		...input.interactions === void 0 ? {} : { interactions: input.interactions }
 	};
 }
-function isAsyncIterable(value) {
-	return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
-}
 /**
 * Pull one provider iterator under Runtime's deadline.
 *
@@ -1188,15 +1184,6 @@ const strategyAuthorMethod = [
 	"   comment at the top of the module — the holdout verdict will be read against it."
 ].join("\n");
 //#endregion
-//#region src/improvement/improve-result.ts
-function copyImproveCost(cost) {
-	return {
-		totalCostUsd: cost.totalCostUsd,
-		accountingComplete: cost.accountingComplete,
-		incompleteReasons: [...cost.incompleteReasons]
-	};
-}
-//#endregion
 //#region src/runtime/profile-chat-client.ts
 /** Profile-exact adapter for packages that consume agent-eval's ChatClient contract.
 * Every call still enters Runtime through createExecutor -> streamAgentTurn, and every
@@ -1532,9 +1519,6 @@ function optimizerTokenCount(value, label) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`profile optimizer ${label} must be a non-negative integer`);
 	return value;
 }
-function errorMessage$1(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 //#endregion
 //#region src/runtime/observe.ts
 /**
@@ -2900,560 +2884,264 @@ function structuralRollout(config = {}) {
 	});
 }
 //#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 } : {}
+//#region src/improvement/search-decision.ts
+/**
+* Runtime's decision on a closed search, made from its records alone: the claim
+* the ledger supports, the cost ledger's accounting, the ship rule, and, when
+* the search ships, the profiles-table promotion that cites the claim.
+*
+* `improve()` applies it when a search closes. `decideSearchImprovement`
+* applies it to a closed search's directory, so a search is decided again under
+* the current rule without running or spending anything. The ship rule is not
+* part of a search's identity: the same ledger re-decided after a rule change is
+* the same search.
+*/
+/**
+* A search's cost as `ImproveCost`: the ledger's summary, plus the bound on the
+* calls whose cost is unknown when each declared a maximum before it ran. Those
+* are calls that failed with no receipt, or that a killed process left pending
+* and a restart settled unknown. Each counts at its maximum, the same bound the
+* ledger enforces its ceiling with.
+*/
+function improveSearchCost(ledger) {
+	const summary = ledger.summary();
+	const cost = {
+		totalCostUsd: summary.totalCostUsd,
+		accountingComplete: summary.accountingComplete,
+		incompleteReasons: [...summary.incompleteReasons]
 	};
+	if (summary.accountingComplete || summary.pendingCalls > 0) return cost;
+	let unknownCalls = 0;
+	let unknownMaximumUsd = 0;
+	for (const receipt of ledger.list()) if (receipt.costUnknown) {
+		if (receipt.maximumCostUsd === void 0) return cost;
+		unknownCalls += 1;
+		unknownMaximumUsd += receipt.maximumCostUsd;
+	} else if (receipt.usageUnknown || receipt.maximumCostUsd !== void 0 && receipt.costUsd > receipt.maximumCostUsd) return cost;
+	if (unknownCalls === 0) return cost;
 	return {
-		...candidate,
-		extensions: {
-			...candidate.extensions,
-			[ROLLOUT_POLICY_EXTENSION]: bag
+		...cost,
+		costBound: {
+			unknownCalls,
+			unknownMaximumUsd,
+			totalMaximumUsd: summary.totalCostUsd + unknownMaximumUsd
 		}
 	};
 }
-//#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");
+/** Runtime's ship rule over the kernel's statistical claim (design §6.5 step 5), shared by
+* `searchMethod` and `runStrategyEvolution`. */
+function runtimeShipDecision(input) {
+	const { claim, cost, costCeiling } = input;
+	if (claim.decision !== "ship") return {
+		decision: "hold",
+		reason: claim.reason
 	};
-	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;
+	if (!input.verified) return {
+		decision: "hold",
+		reason: "the claim shipped, but it does not re-derive from the ledger under this rule revision"
+	};
+	const bound = cost.accountingComplete ? void 0 : cost.costBound;
+	if (!cost.accountingComplete && bound === void 0) return {
+		decision: "hold",
+		reason: "the claim shipped, but the search cost accounting is incomplete"
+	};
+	if (bound && costCeiling !== void 0 && bound.totalMaximumUsd > costCeiling) return {
+		decision: "hold",
+		reason: `the claim shipped, but ${bound.unknownCalls} call(s) of unknown cost, counted at their declared maximum, put the search at up to $${dollars$1(bound.totalMaximumUsd)}, above its $${dollars$1(costCeiling)} ceiling`
+	};
+	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}`
 	};
-}
-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
+		decision: "ship",
+		reason: bound ? `${claim.reason}; ${bound.unknownCalls} call(s) ended with no receipt and count at their declared maximum, $${dollars$1(bound.unknownMaximumUsd)}, so the search cost at most $${dollars$1(bound.totalMaximumUsd)}${costCeiling === void 0 ? "" : ` of its $${dollars$1(costCeiling)} ceiling`}` : claim.reason
 	};
 }
-function assertFailClosedResources(profile, surface) {
-	if (profile.resources?.failOnError !== true) throw new ConfigError(`improve(): surface '${surface}' requires profile.resources.failOnError: true`);
-}
-//#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.
+* Decide a closed search: the ship rule, and the promotion when it ships.
+* `profileOf` returns the exact profile a node holds.
 */
-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)
+async function decideClosedSearch(input) {
+	const { claim, state } = input;
+	const shipped = claim.finalists.find((finalist) => finalist.nodeId === claim.selected && finalist.test !== null);
+	const ruled = runtimeShipDecision({
+		claim,
+		verified: input.claimVerification.status === "verified",
+		cost: input.cost,
+		costCeiling: input.costCeiling,
+		lowerBound: shipped?.test?.interval[0] ?? null,
+		minimumLift: input.minimumLift
 	});
-	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
+	const lift = shipped?.test ? {
+		lift: shipped.test.delta,
+		liftInterval: {
+			low: shipped.test.interval[0],
+			high: shipped.test.interval[1]
+		}
+	} : {};
+	if (ruled.decision !== "ship") return {
+		...ruled,
+		...lift
 	};
-}
-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() : []
+	const promotion = await searchPromotion(state, claim, input.profileOf);
+	if ("refused" in promotion) return {
+		decision: "hold",
+		reason: `${ruled.reason}; held: ${promotion.refused}`,
+		...lift
 	};
-}
-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
+		...ruled,
+		...lift,
+		promotion
 	};
 }
-//#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.
+* The claim as a profiles-table promotion. The sealed experiment states the
+* claim's design: the root as control and every finalist the claim tested as a
+* treatment, each by its exact profile digest, fixed before any test cell ran.
+* The decision is Eval's paired decision for the selected finalist, made again
+* from the ledger by `searchClaimDecision`. The seal is dated by the search's
+* close, so the same ledger always yields the same promotion.
 */
-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;
+async function searchPromotion(state, claim, profileOf) {
+	const header = state.header;
+	const closed = state.closed;
+	const root = state.rootNodeId;
+	const selected = claim.selected;
+	if (!header || !closed || root === null || selected === null) return { refused: "the ledger holds no closed claim with a selected finalist" };
+	const decision = searchClaimDecision(state, selected);
+	if (decision === null || decision.promote !== true) return { refused: `Eval's paired decision for ${selected} does not promote` };
+	if (!("adequate" in claim.power)) return { refused: "the claim tested its finalists without a known power" };
+	const tested = claim.finalists.filter((finalist) => finalist.test !== null);
+	const estimator = claim.power.estimator;
+	let outcome;
+	if (estimator.kind === "binary") outcome = {
+		kind: "binary",
+		pass: `the per-unit test mean equals ${estimator.scale}`
 	};
-	materializeProfile(baselineSurface);
+	else {
+		if ([root, ...tested.map((finalist) => finalist.nodeId)].flatMap((nodeId) => state.unitScores(nodeId, "test").map((unit) => unit.mean)).some((score) => score < 0 || score > 1)) return { refused: "a test score leaves the campaign's [0, 1] score scale" };
+		outcome = {
+			kind: "bounded-score",
+			min: 0,
+			max: 1,
+			orientation: header.objective.direction === "maximize" ? "higher-is-better" : "lower-is-better"
+		};
+	}
+	const arm = (nodeId, role) => ({
+		id: nodeId,
+		role,
+		profileDigest: canonicalAgentProfileDigest(profileOf(nodeId)),
+		pins: {
+			searchId: state.searchId,
+			nodeId
+		}
+	});
+	const testUnits = new Set(header.splits.test.tasks.map((task) => task.unitId)).size;
 	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)
+		experiment: await sealExperiment({
+			id: `${state.searchId}.claim`,
+			claim: header.objective.claim,
+			hypothesis: `Each finalist of search ${state.searchId} beats the root on its ${testUnits} sealed test units at confidence ${tested[0]?.test?.confidence ?? claim.confidence}, by Eval's paired decision (${claim.rule.uri} ${claim.rule.revision}); the claim fixed these arms before any test cell ran.`,
+			arms: [arm(root, "control"), ...tested.map((finalist) => arm(finalist.nodeId, "treatment"))],
+			outcome,
+			decision: {
+				kind: "report-only",
+				estimands: [],
+				intervals: [],
+				perRow: []
 			},
-			model: profileModel(profile)
-		}),
-		surfaceOf: (candidate) => prepareProfileSurface(candidate, surface, skills, profileComponents).surface,
-		materializeCandidate: rawMaterializeProfile,
-		admitCandidate,
-		materializeProfile,
-		validateMaterialized
+			seed: header.policy.seed
+		}, { sealedAt: closed.occurredAt }),
+		decision
 	};
 }
-/** 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"
-	};
+/**
+* Decide a closed search from its directory, under the current ship rule, with
+* no model call: the claim verified from the ledger, the cost from its cost
+* ledger, and the promotion when it ships. Use it to cite a finished search as
+* a registry promotion, or to re-decide one that an earlier rule held.
+*/
+async function decideSearchImprovement(options) {
+	const storage = options.storage ?? fsCampaignStorage();
+	const minimumLift = options.minimumLift ?? 0;
+	if (!Number.isFinite(minimumLift) || minimumLift < 0) throw new ConfigError("decideSearchImprovement(): minimumLift must be a finite number of at least 0");
+	const ledgerPath = join(options.searchDir, "ledger.jsonl");
+	const text = storage.read(ledgerPath);
+	if (text === void 0) throw new ConfigError(`decideSearchImprovement(): no search ledger at ${ledgerPath}`);
+	const first = text.slice(0, text.indexOf("\n"));
+	const searchId = JSON.parse(first).searchId;
+	if (typeof searchId !== "string") throw new ConfigError(`decideSearchImprovement(): ${ledgerPath} names no searchId`);
+	const state = await (storage.kind === "filesystem" ? openSearchLedger({
+		path: ledgerPath,
+		searchId
+	}) : openSearchLedger({
+		path: ledgerPath,
+		searchId,
+		store: storage
+	})).state();
+	const claim = state.closed?.claim;
+	if (!state.closed || !claim) throw new ConfigError(`decideSearchImprovement(): search ${searchId} is ${state.closed ? "closed without a claim" : "still open"}`);
+	const costLedger = options.costLedger ?? createRunCostLedger({
+		storage,
+		runDir: options.searchDir,
+		ensureRunDir: false
+	});
+	const profileOf = searchProfileReader(state, storage, dirname(ledgerPath));
+	const cost = improveSearchCost(costLedger);
+	const claimVerification = verifySearchClaim(state);
+	const decided = await decideClosedSearch({
+		state,
+		claim,
+		claimVerification,
+		cost,
+		costCeiling: state.header?.budget.maxUsd ?? void 0,
+		minimumLift,
+		profileOf
+	});
+	const root = state.rootNodeId;
 	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"
+		searchId,
+		claim,
+		claimVerification,
+		cost,
+		...decided,
+		baseline: profileOf(root),
+		candidate: profileOf(claim.selected ?? root)
+	};
+}
+/** Each node's exact profile from the search's blob store, checked against
+* the blob's content address and the node's profile digest. */
+function searchProfileReader(state, storage, dir) {
+	const read = /* @__PURE__ */ new Map();
+	return (nodeId) => {
+		const known = read.get(nodeId);
+		if (known) return known;
+		const node = state.node(nodeId);
+		if (!node) throw new ConfigError(`decideSearchImprovement(): no node ${nodeId}`);
+		const stored = readBlob(storage, dir, node.artifact);
+		const parsed = agentProfileSchema.safeParse(stored.profile);
+		if (stored.kind !== "agent-profile" || !parsed.success) throw new ConfigError(`decideSearchImprovement(): node ${nodeId} holds no AgentProfile`);
+		const profile = immutableCandidateValue(parsed.data);
+		if (canonicalAgentProfileDigest(profile) !== node.artifactDigest) throw new ConfigError(`decideSearchImprovement(): node ${nodeId}'s profile does not match its digest ${node.artifactDigest}`);
+		read.set(nodeId, profile);
+		return profile;
 	};
 }
+/** A blob the search stored, read from the blob directory beside its ledger,
+* whatever directory the ledger was written in, and checked against its digest. */
+function readBlob(storage, dir, ref) {
+	const hex = ref.sha256.slice(7);
+	const path = join(dir, "blobs", `${hex}.json`);
+	const text = storage.read(path);
+	if (text === void 0) throw new ConfigError(`decideSearchImprovement(): missing blob ${path}`);
+	if (createHash("sha256").update(text, "utf8").digest("hex") !== hex) throw new ConfigError(`decideSearchImprovement(): blob ${path} does not match its digest`);
+	return JSON.parse(text);
+}
+function dollars$1(value) {
+	return value.toFixed(value < 1 ? 4 : 2);
+}
 //#endregion
 //#region src/runtime/shared-box.ts
 /**
@@ -5092,587 +4780,6 @@ function otelSpan(input) {
 	};
 }
 //#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",
-		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, 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 = 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), shared by
-* `searchMethod` and `runStrategyEvolution`. */
-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,
-		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
-export { sampleThenRefine as $, parseRolloutPolicy as A, officialChecksFromMeta as B, privateValuePaths as C, ROLLOUT_POLICY_EXTENSION as D, isCodeSurface as E, composeCheckSources as F, visibleCheckScore as G, sandboxCheckRunner as H, defaultExtractCandidate as I, defineStrategy as J, adaptiveRefine as K, defaultStructuralRolloutPolicy as L, structuralRolloutPolicyFromProfile as M, canDisplace as N, applyRolloutPolicyToProfile as O, compareCheckOutcomes as P, sample as Q, filterAuthoredAsserts as R, parseExecutionRef as S, assertCandidateSurfaceKind as T, selectBestIndex as U, resolveEntrySymbol as V, structuralRollout as W, refine as X, depthStrategy as Y, runAgentic as Z, sharedBoxRefusal as _, startOrResumeRuntimeSession as _t, SearchEnvironmentFault as a, profileOptimizerModelCall as at, assertCandidateValidator as b, reconcileInterruptedSearchCalls as c, strategyAuthorMethod as ct, sharedBoxLane as d, createIterableBackend as dt, ObservationError as et, subscriptionLane as f, createSandboxPromptBackend as ft, sharedBoxPlacement as g, nowIso as gt, ROUTER_CLIENT_HEADER as h, newRuntimeSession as ht, searchMethod as i, profileChatClient as it, serializeRolloutPolicy as j, normalizeRolloutPolicy as k, routerLane as l, collectAgentTurn as lt, DEFAULT_SHARED_BOX_WORKERS as m, InMemoryRuntimeSessionStore as mt, runSearchImprovement as n, observe as nt, dedicatedLane as o, copyImproveCost as ot, DEFAULT_SHARED_BOX_RESOURCES as p, normalizeBackendStreamEvent as pt, breadthStrategy as q, runtimeShipDecision as r, renderReport as rt, isSearchEnvironmentFault as s, optimizerMethod as st, isImproveSearchMethod as t, defaultAnalystInstruction as tt, searchExecutor as u, streamAgentTurn as ut, sharedWorkerClientName as v, touchSession as vt, validateProfileCandidate as w, assertProfileTrainingIsHeldOut as x, prepareProfileImprovement as y, modelAuthoredChecks as z };
+export { createIterableBackend as $, resolveEntrySymbol as A, runAgentic as B, compareCheckOutcomes as C, filterAuthoredAsserts as D, defaultStructuralRolloutPolicy as E, adaptiveRefine as F, observe as G, sampleThenRefine as H, breadthStrategy as I, profileOptimizerModelCall as J, renderReport as K, defineStrategy as L, selectBestIndex as M, structuralRollout as N, modelAuthoredChecks as O, visibleCheckScore as P, streamAgentTurn as Q, depthStrategy as R, canDisplace as S, defaultExtractCandidate as T, ObservationError as U, sample as V, defaultAnalystInstruction as W, strategyAuthorMethod as X, optimizerMethod as Y, collectAgentTurn as Z, sharedWorkerClientName as _, reconcileInterruptedSearchCalls as a, startOrResumeRuntimeSession as at, improveSearchCost as b, searchExecutor as c, taggedLedger as d, createSandboxPromptBackend as et, DEFAULT_SHARED_BOX_RESOURCES as f, sharedBoxRefusal as g, sharedBoxPlacement as h, isSearchEnvironmentFault as i, nowIso as it, sandboxCheckRunner as j, officialChecksFromMeta as k, sharedBoxLane as l, ROUTER_CLIENT_HEADER as m, assertSearchLanes as n, InMemoryRuntimeSessionStore as nt, routerLane as o, touchSession as ot, DEFAULT_SHARED_BOX_WORKERS as p, profileChatClient as q, dedicatedLane as r, newRuntimeSession as rt, searchCallTags as s, SearchEnvironmentFault as t, normalizeBackendStreamEvent as tt, subscriptionLane as u, decideClosedSearch as v, composeCheckSources as w, runtimeShipDecision as x, decideSearchImprovement as y, refine as z };
 
-//# sourceMappingURL=search-method-DvU-fc-f.js.map
+//# sourceMappingURL=search-executor-2tWr38Qw.js.map