@tangle-network/agent-runtime 0.280.0 → 0.281.1

package/dist/{improvement-cycle-DXMU-2Y4.js → improvement-cycle-DCTCTmNl.js}

@@ -1,6 +1,6 @@
-import { $i as detachedSnapshot, At as createExecutor, Cr as runAbortable, Ia as armDeadlineTimer, Qr as runSettledCommand, Sr as linkAbort, ui as terminateProcessTreeAndConfirm } from "./supervisor-BXXjVCbW.js";
+import { $i as detachedSnapshot, $r as runSettledCommand, Br as createOpenInferenceFileExporter, Cr as linkAbort, Gr as padSpanId, Ia as armDeadlineTimer, K as openSlotGroup, Kr as padTraceId, Ur as generateSpanId, Vr as createOtelExporter, di as terminateProcessTreeAndConfirm, jt as createExecutor, qr as toOtelAttributes, wr as runAbortable } from "./supervisor-UXgaPisu.js";
 import { i as ConfigError } from "./errors-DodWX-cb.js";
-import { A as collectAgentTurn, O as optimizerMethod, a as defaultStructuralRolloutPolicy, j as streamAgentTurn } from "./structural-rollout-Cl4TvomY.js";
+import { F as optimizerMethod, L as collectAgentTurn, R as streamAgentTurn, a as sharedBoxPlacement, f as defaultStructuralRolloutPolicy, i as isTransientSandboxFailure } from "./shared-box-CZFdugL1.js";
 import { a as concreteProfileModel, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { A as verifyCanonicalCandidateDocument, C as canonicalCandidateDigest$1, D as immutableCandidateValue, O as omitTopLevelDigest, S as canonicalCandidateBytes$1, k as sha256Bytes$1, w as canonicalCandidateDocument } from "./workspace-archive-C9lgf77y.js";
 import { i as syncDurableDirectory, r as publishExclusiveDurableFile } from "./durable-file-DWQA4ooo.js";
@@ -8,16 +8,17 @@ import { t as runAnalystLoop } from "./analyst-loop-DZw5QWT9.js";
 import { c as executePreparedAgentCandidate, o as verifiedResourceTextByDigest, s as verifyAgentCandidateBundle, t as prepareAgentCandidateExecution } from "./prepare-DVlvGP7V.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-D3eXNBQV.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 { CostAccountingIncompleteError, CostCeilingReachedError, CostLedger, canonicalJson, costForTokenPricing, costForUsage, 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 { constants, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } 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 { 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, compareOptimizationMethods, createRunCostLedger, fsCampaignStorage, gitWorktreeAdapter, isProposedCandidate, openSearchLedger, renderSearchSummary, resolveRunDir, runCampaign, runSearch, searchClaimReserveUsd, searchProposalExecution, searchProposerView, searchReceiptAccounting, 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
@@ -2044,6 +2045,651 @@ async function runMethodImprovement(profile, opts) {
 	};
 }
 //#endregion
+//#region src/improvement/search-executor.ts
+/**
+* The search kernel's executor port for cells Runtime runs.
+*
+* A lane is a pool of execution slots with one cost rule: a shared box, dedicated
+* environments, subscription seats, or the router. The kernel places each cell on a lane and
+* bounds each lane's running cells by its capacity. This executor adds what one search cannot
+* see or enforce on its own:
+*
+* - Fleet slots. A `WorkerSlots` allocator shared by concurrent searches bounds working cells
+*   across all of them. A cell waits for a slot, and the wait is its `queueMs`.
+* - Fleet dollars. On a hard lane a cell holds its enforced maximum as a `BudgetPool` ticket
+*   before it starts, waits while open tickets could return enough, and settles the ticket
+*   with its measured spend. Estimate lanes take no ticket: they cannot bound a cell, and an
+*   unknown cost would close a capped pool for every search that shares it.
+* - Hard caps. On a hard lane every paid call of the cell, the agent's and the judges', holds
+*   its maximum against the lane's `cellUsd` and is refused when it would pass it, so the
+*   kernel's hard reservation is a bound and not a hope.
+* - Adoption. A finished attempt is written under its run id before the kernel sees it, so a
+*   kernel that restarts adopts the attempt instead of running it again. The run id is stable
+*   across restarts; an agent that runs remote work keys it by `ctx.search.runId`, so a lost
+*   response is fetched again rather than executed again.
+* - Accounting. Every paid call is tagged with its search and attempt, and an attempt's cost is
+*   every call tagged with its run id, including calls a process that ended made for it. A
+*   reopened search settles those interrupted calls first: from the provider through the lane's
+*   `recoverReceipt`, else with an unknown cost, never as free.
+* - Environment faults. A `SearchEnvironmentFault`, or a platform failure a repeated request
+*   can change, settles `errored` and retryable, and the kernel runs a fresh attempt.
+* - Traces. Each attempt is one trace whose root span carries `agent.branch.id` = the node id.
+*   The spans the attempt's exporter wrote and dropped go into the cell's `traceRef`.
+*/
+function laneReceipts(options) {
+	return options.recoverReceipt ? { recoverReceipt: options.recoverReceipt } : {};
+}
+const acceptEveryProfile = () => void 0;
+function laneName(name, fallback) {
+	const resolved = name ?? fallback;
+	if (!/^[A-Za-z0-9._-]{1,64}$/u.test(resolved)) throw new ConfigError(`search lane name '${resolved}' must be 1-64 of [A-Za-z0-9._-]`);
+	return resolved;
+}
+function positiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new ConfigError(`${name} must be a positive integer`);
+	return value;
+}
+function dollars(value, name) {
+	if (!Number.isFinite(value) || value < 0) throw new ConfigError(`${name} must be a finite non-negative number of dollars`);
+	return value;
+}
+/**
+* Cells as workers packed into shared Sandbox boxes, `workersPerBox` to a box.
+*
+* Capacity is `boxes × workersPerBox`. The workers of one box share its router key, which caps
+* no single worker, so the lane holds an estimate (`cellUsd` is the prior until 20 cells settle).
+* A profile the placement refuses (a repository writer, a replaced system prompt, MCP servers,
+* hooks, subagents, tool grants) needs another lane. The agent reaches the box through
+* `lane.placement.providerFor({ nodeId: ctx.search.runId })`, which names the attempt to the
+* router on every call.
+*/
+function sharedBoxLane(options) {
+	const { name, boxes, cellUsd, recoverReceipt, ...placementOptions } = options;
+	const placement = sharedBoxPlacement(placementOptions);
+	const workersPerBox = placementOptions.workersPerBox ?? 8;
+	return Object.freeze({
+		name: laneName(name, "shared-box"),
+		kind: "shared-box",
+		capacity: positiveInteger(boxes, "sharedBoxLane(): boxes") * workersPerBox,
+		costCap: "estimate",
+		cellUsd: dollars(cellUsd, "sharedBoxLane(): cellUsd"),
+		refusal: (profile) => placement.refusal(profile),
+		...laneReceipts({ recoverReceipt }),
+		placement
+	});
+}
+/**
+* Cells that each run in their own environment, `capacity` at once. The lane cannot bound a
+* cell's dollars, so it holds an estimate: `cellUsd` until 20 cells settle, then 1.5 × the p99
+* of its settled cells.
+*/
+function dedicatedLane(options) {
+	return Object.freeze({
+		name: laneName(options.name, "dedicated"),
+		kind: "dedicated",
+		capacity: positiveInteger(options.capacity, "dedicatedLane(): capacity"),
+		costCap: "estimate",
+		cellUsd: dollars(options.cellUsd, "dedicatedLane(): cellUsd"),
+		refusal: acceptEveryProfile,
+		...laneReceipts(options)
+	});
+}
+/**
+* Cells on subscription seats, one cell a seat. A seat charges no dollar per call, so its own
+* work costs $0 and reports no tokens. `cellUsd` bounds the cell's priced calls, such as its
+* judges; every one of them must declare a maximum, and the lane refuses a call past it.
+*/
+function subscriptionLane(options) {
+	return Object.freeze({
+		name: laneName(options.name, "subscription"),
+		kind: "subscription",
+		capacity: positiveInteger(options.seats, "subscriptionLane(): seats"),
+		costCap: "hard",
+		cellUsd: dollars(options.cellUsd ?? 0, "subscriptionLane(): cellUsd"),
+		refusal: acceptEveryProfile,
+		...laneReceipts(options)
+	});
+}
+/**
+* Cells whose model calls are priced router calls, `capacity` at once. Every paid call of a
+* cell must declare its maximum charge, and the lane refuses a call that would take the cell
+* past `cellUsd`, so `cellUsd` is each cell's hard maximum.
+*/
+function routerLane(options) {
+	return Object.freeze({
+		name: laneName(options.name, "router"),
+		kind: "router",
+		capacity: positiveInteger(options.capacity, "routerLane(): capacity"),
+		costCap: "hard",
+		cellUsd: dollars(options.cellUsd, "routerLane(): cellUsd"),
+		refusal: acceptEveryProfile,
+		...laneReceipts(options)
+	});
+}
+/** Check a lane list: at least one lane, unique names, a hard lane's cap known. */
+function assertSearchLanes(lanes, context) {
+	if (!Array.isArray(lanes) || lanes.length === 0) throw new ConfigError(`${context}: lanes needs at least one lane`);
+	const names = /* @__PURE__ */ new Set();
+	for (const lane of lanes) {
+		if (!lane || typeof lane.refusal !== "function" || typeof lane.kind !== "string") throw new ConfigError(`${context}: every lane comes from sharedBoxLane, dedicatedLane, subscriptionLane or routerLane`);
+		if (names.has(lane.name)) throw new ConfigError(`${context}: lane '${lane.name}' appears twice`);
+		names.add(lane.name);
+	}
+}
+/**
+* The environment, not the candidate, ended the attempt: a box that died, a platform that
+* refused the run, a quota. The attempt settles `errored` and retryable, and the kernel runs a
+* fresh attempt up to its `maxAttempts`. Throw anything else for the agent's own failure.
+*/
+var SearchEnvironmentFault = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "SearchEnvironmentFault";
+	}
+};
+/** Whether an attempt's error is the environment's: a `SearchEnvironmentFault`, or a platform,
+*  gateway or network failure that a repeated request can change. */
+function isSearchEnvironmentFault(error) {
+	return error instanceof SearchEnvironmentFault || isTransientSandboxFailure(error);
+}
+const USD_TOLERANCE = 1e-9;
+/** The kernel's executor port over Runtime lanes. */
+function searchExecutor(options) {
+	assertSearchLanes(options.lanes, "searchExecutor()");
+	const lanes = new Map(options.lanes.map((lane) => [lane.name, lane]));
+	const placed = new Map(options.lanes.map((lane) => [lane.name, 0]));
+	const slots = options.workerSlots ? openSlotGroup(options.workerSlots) : null;
+	const attempts = attemptStore(options.storage, join(options.dir, "attempts"));
+	const tracing = searchTracing(options);
+	const laneOf = (work) => {
+		const lane = lanes.get(work.lane);
+		if (!lane) throw new Error(`search cell ${work.cellId} was placed on unknown lane '${work.lane}'`);
+		return lane;
+	};
+	return {
+		lanes: () => options.lanes,
+		place(cell) {
+			const profile = options.profileOf(cell.nodeId);
+			let chosen;
+			for (const lane of options.lanes) {
+				if (profile && lane.refusal(profile) !== void 0) continue;
+				if (chosen === void 0 || placed.get(lane.name) / lane.capacity < placed.get(chosen.name) / chosen.capacity) chosen = lane;
+			}
+			if (!chosen) throw new Error(`no search lane can run node ${cell.nodeId}; admission should have refused it`);
+			placed.set(chosen.name, placed.get(chosen.name) + 1);
+			return chosen.name;
+		},
+		async adopt(work) {
+			return attempts.read(work.runId);
+		},
+		async run(work) {
+			const lane = laneOf(work);
+			const queuedAt = Date.now();
+			let hold;
+			try {
+				hold = await holdFleet(lane, work, options.budgetPool, slots);
+			} catch (error) {
+				if (work.signal.aborted) return interrupted(work, lane, options.identity, error);
+				throw error;
+			}
+			const queueMs = Date.now() - queuedAt;
+			const trace = tracing.open(work, lane);
+			let result;
+			try {
+				const context = Object.freeze({
+					searchId: work.searchId,
+					cellId: work.cellId,
+					nodeId: work.nodeId,
+					taskId: work.taskId,
+					split: work.split,
+					stage: work.stage,
+					attempt: work.attempt,
+					runId: work.runId,
+					lane,
+					trace: trace.ids
+				});
+				const tags = searchCallTags(work.searchId, {
+					run: work.runId,
+					lane: lane.name
+				});
+				const measured = await options.runAttempt({
+					work,
+					lane,
+					context,
+					costLedger: attemptLedger(options.costLedger, lane, tags),
+					span: trace.span
+				});
+				result = {
+					...measured,
+					accounting: attemptAccounting(options.costLedger, lane, tags),
+					queueMs,
+					placement: {
+						lane: lane.name,
+						boxId: measured.placement?.boxId ?? null
+					},
+					traceRef: await trace.finish(measured)
+				};
+			} finally {
+				hold.release(result);
+			}
+			if (!work.signal.aborted) attempts.write(work.runId, result);
+			return result;
+		}
+	};
+}
+function interrupted(work, lane, identity, error) {
+	return {
+		outcome: {
+			status: "errored",
+			metrics: {},
+			error: {
+				code: "interrupted",
+				message: `search cell ${work.runId} was interrupted before it ran: ${error instanceof Error ? error.message : String(error)}`,
+				retryable: true
+			}
+		},
+		accounting: {
+			tokens: {
+				status: "known",
+				inputTokens: 0,
+				outputTokens: 0,
+				cachedTokens: 0
+			},
+			cost: {
+				status: "known",
+				usd: 0,
+				source: "free"
+			}
+		},
+		identity,
+		placement: {
+			lane: lane.name,
+			boxId: null
+		},
+		traceRef: { unknown: "the attempt never started" }
+	};
+}
+/** Take the attempt's fleet dollars, then its fleet slot. A cell waiting for budget holds no
+*  slot, so it cannot hold a slot the cells it waits on need. */
+async function holdFleet(lane, work, pool, slots) {
+	let ticket;
+	if (pool && lane.costCap === "hard" && lane.cellUsd > 0) {
+		const reserved = pool.reserve({
+			maxUsd: lane.cellUsd,
+			maxTokens: 0,
+			maxIterations: 0
+		}, {
+			label: work.runId,
+			stage: "admitted"
+		}, { wait: true });
+		if (!reserved.ok) throw new Error(`the fleet budget pool refused search cell ${work.runId} on lane ${lane.name}: ${reserved.reason}`);
+		ticket = reserved.ticket;
+		if (reserved.granted) try {
+			await abortable(reserved.granted, work.signal);
+		} catch (error) {
+			pool.reconcile(ticket, noSpend());
+			throw error;
+		}
+		pool.attribute(ticket, {
+			label: work.runId,
+			stage: "executing"
+		});
+	}
+	const permit = slots?.acquire(0);
+	if (permit) try {
+		await abortable(permit.ready, work.signal);
+	} catch (error) {
+		permit.release();
+		if (ticket) pool.reconcile(ticket, noSpend());
+		throw error;
+	}
+	return { release(result) {
+		permit?.release();
+		if (!ticket) return;
+		try {
+			pool.reconcile(ticket, result ? spendOf(result) : unknownSpend());
+		} catch {}
+	} };
+}
+function abortable(promise, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("search cell aborted"));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(signal.reason ?? /* @__PURE__ */ new Error("search cell aborted"));
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+function noSpend() {
+	return {
+		iterations: 0,
+		tokens: {
+			input: 0,
+			output: 0
+		},
+		usd: 0,
+		ms: 0
+	};
+}
+function unknownSpend() {
+	return {
+		...noSpend(),
+		usdKnown: false,
+		tokensKnown: false
+	};
+}
+/** The attempt's spend as the budget pool reads it. Unknown dollars carry their proven floor. */
+function spendOf(result) {
+	const { cost, tokens } = result.accounting;
+	return {
+		iterations: 0,
+		tokens: tokens.status === "known" ? {
+			input: tokens.inputTokens,
+			output: tokens.outputTokens
+		} : {
+			input: 0,
+			output: 0
+		},
+		...tokens.status === "known" ? {} : { tokensKnown: false },
+		usd: cost.status === "known" ? cost.usd : cost.knownLowerBoundUsd,
+		...cost.status === "known" ? {} : { usdKnown: false },
+		ms: result.wallMs ?? 0
+	};
+}
+/** The dollar maximum a paid call declares, or null when it declares no priced one. */
+function chargeMaximumUsd(maximum) {
+	if (!maximum) return null;
+	if ("externallyEnforcedMaximumUsd" in maximum) return maximum.externallyEnforcedMaximumUsd;
+	if ("customTokenPricing" in maximum) return costForTokenPricing(maximum.customTokenPricing, maximum);
+	const priced = costForUsage(maximum.model, maximum);
+	return priced.costUnknown ? null : priced.costUsd;
+}
+const TAG_SEARCH = "searchId";
+const TAG_RUN = "searchRunId";
+const TAG_LANE = "searchLane";
+const TAG_OPERATION = "searchOperation";
+/** The cost-ledger tags of one search's calls: a cell attempt's, or a proposal operation's. */
+function searchCallTags(searchId, of) {
+	return "run" in of ? {
+		[TAG_SEARCH]: searchId,
+		[TAG_RUN]: of.run,
+		[TAG_LANE]: of.lane
+	} : {
+		[TAG_SEARCH]: searchId,
+		[TAG_OPERATION]: of.operation
+	};
+}
+/** The search ledger with `tags` added to every paid call. */
+function taggedLedger(ledger, tags) {
+	return ledgerView(ledger, (input) => ledger.runPaidCall({
+		...input,
+		tags: {
+			...input.tags,
+			...tags
+		}
+	}));
+}
+function ledgerView(ledger, runPaidCall) {
+	return new Proxy(ledger, { get(target, property) {
+		if (property === "runPaidCall") return runPaidCall;
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+/**
+* The search ledger seen by one attempt: every paid call carries the attempt's tags. On a hard
+* lane every call also holds its declared maximum against the lane's `cellUsd` until its
+* receipt replaces the hold with the charge, and a call that would pass the cap, or declares no
+* priced maximum, is refused. A charge the provider left unknown keeps its maximum held.
+*/
+function attemptLedger(ledger, lane, tags) {
+	const tagged = taggedLedger(ledger, tags);
+	if (lane.costCap !== "hard") return tagged;
+	let heldUsd = 0;
+	const runPaidCall = async (input) => {
+		const maximumUsd = chargeMaximumUsd(input.maximumCharge);
+		if (maximumUsd === null) return {
+			succeeded: false,
+			error: new CostAccountingIncompleteError(`lane ${lane.name} caps each cell at $${lane.cellUsd}, so paid call '${input.actor}' during '${input.phase}' needs a priced maximumCharge`)
+		};
+		if (heldUsd + maximumUsd > lane.cellUsd + USD_TOLERANCE) return {
+			succeeded: false,
+			error: new CostCeilingReachedError(lane.cellUsd, heldUsd, maximumUsd, input.phase, input.actor)
+		};
+		heldUsd += maximumUsd;
+		const result = await tagged.runPaidCall(input);
+		const { receipt } = result;
+		if (receipt && !receipt.costUnknown) heldUsd += receipt.costUsd - maximumUsd;
+		return result;
+	};
+	return ledgerView(tagged, runPaidCall);
+}
+/**
+* An attempt's cost is every call tagged with its run id, a call a process that ended made for
+* it included; a call still pending makes the cost unknown with the settled calls as its floor.
+* A subscription seat reports no tokens, and its own work charges no dollar.
+*/
+function attemptAccounting(ledger, lane, tags) {
+	const receipts = ledger.list({ tags });
+	const accounting = searchReceiptAccounting(receipts);
+	const pending = ledger.listPending?.({ tags }) ?? [];
+	const floorUsd = accounting.cost.status === "known" ? accounting.cost.usd : accounting.cost.knownLowerBoundUsd;
+	const cost = pending.length > 0 ? {
+		status: "unknown",
+		knownLowerBoundUsd: floorUsd,
+		reason: `${pending.length} paid call(s) of the attempt had no receipt when it ended`
+	} : accounting.cost.status === "known" && accounting.cost.usd > 0 && receipts.some((receipt) => receipt.actualCostUsd === void 0) ? {
+		...accounting.cost,
+		source: "pricing-table"
+	} : accounting.cost;
+	return {
+		tokens: lane.kind === "subscription" ? {
+			status: "unknown",
+			reason: "a subscription seat reports no token usage"
+		} : accounting.tokens,
+		cost
+	};
+}
+/**
+* Settle every paid call of `searchId` that a process which ended left pending, before the
+* reopened search makes a new one: a capped ledger refuses new paid work while one is
+* unresolved. A cell's call is asked of its lane's provider through `recoverReceipt`; any other
+* call, or one the provider cannot answer, settles failed with an unknown cost.
+*/
+async function reconcileInterruptedSearchCalls(ledger, searchId, lanes) {
+	const interrupted = (ledger.listPending?.({ tags: { [TAG_SEARCH]: searchId } }) ?? []).filter((call) => call.state === "interrupted");
+	let recovered = 0;
+	for (const call of interrupted) {
+		const receipt = await lanes.find((candidate) => candidate.name === call.tags?.[TAG_LANE])?.recoverReceipt?.(call) ?? null;
+		if (receipt) {
+			ledger.reconcile(call.callId, receipt);
+			recovered += 1;
+		} else ledger.reconcile(call.callId, {
+			model: call.model,
+			inputTokens: 0,
+			outputTokens: 0,
+			costUnknown: true,
+			usageUnknown: true
+		}, { error: "the process that made this call ended before its receipt" });
+	}
+	return {
+		recovered,
+		unknown: interrupted.length - recovered
+	};
+}
+/** Finished attempts by run id: the record a restarted kernel adopts. */
+function attemptStore(storage, dir) {
+	const pathOf = (runId) => join(dir, `${runId.replace(/[^A-Za-z0-9_-]/gu, ".")}.json`);
+	storage.ensureDir(dir);
+	return {
+		read(runId) {
+			const text = storage.read(pathOf(runId));
+			if (text === void 0) return null;
+			const record = JSON.parse(text);
+			if (record.runId !== runId || !record.result) throw new Error(`attempt record ${pathOf(runId)} does not hold run ${runId}`);
+			return record.result;
+		},
+		write(runId, result) {
+			const text = `${JSON.stringify({
+				runId,
+				result
+			})}\n`;
+			const path = pathOf(runId);
+			if (storage.kind !== "filesystem") {
+				storage.write(path, text);
+				return;
+			}
+			mkdirSync(dirname(path), { recursive: true });
+			const temporary = `${path}.${process.pid}.tmp`;
+			writeFileSync(temporary, text);
+			renameSync(temporary, path);
+		}
+	};
+}
+const STATUS_OK = 1;
+const STATUS_ERROR = 2;
+const MAX_ATTRIBUTE_CHARS = 256;
+function searchTracing(options) {
+	const mode = options.trace;
+	const fileExporter = mode === void 0 && options.storage.kind === "filesystem" ? createOpenInferenceFileExporter(join(options.dir, "spans.otlp.jsonl")) : void 0;
+	const off = (reason) => ({
+		ids: null,
+		span: () => ({
+			setAttribute() {},
+			end() {}
+		}),
+		finish: async () => ({ unknown: reason })
+	});
+	return { open(work, lane) {
+		if (mode === "off") return off("tracing is off for this search");
+		const exporter = mode === void 0 ? fileExporter : createOtelExporter(mode.otlp);
+		if (!exporter) return off(mode === void 0 ? "the search storage is not the filesystem and no OTLP exporter was configured" : "the OTLP exporter has no endpoint");
+		return attemptTrace(work, lane, exporter, mode !== void 0);
+	} };
+}
+/**
+* One attempt's trace. Its ids derive from the run id, so an attempt run again after a restart
+* writes into the same trace. A shared file exporter writes each span synchronously, so the
+* attempt's written and dropped counts are the change in the exporter's own counts across each
+* of its spans; an attempt's own OTLP exporter is shut down at the end and read whole.
+*/
+function attemptTrace(work, lane, exporter, ownsExporter) {
+	const traceId = padTraceId(`search-cell:${work.runId}`);
+	const rootSpanId = padSpanId(`search-cell:${work.runId}`);
+	const startMs = Date.now();
+	let written = 0;
+	let dropped = 0;
+	const exportCounted = (span) => {
+		if (ownsExporter) {
+			exporter.exportSpan(span);
+			return;
+		}
+		const before = exporter.stats();
+		exporter.exportSpan(span);
+		const after = exporter.stats();
+		written += after.written - before.written;
+		dropped += after.dropped - before.dropped;
+	};
+	return {
+		ids: {
+			traceId,
+			spanId: rootSpanId
+		},
+		span(name, attributes = {}) {
+			const opened = Date.now();
+			const record = { ...attributes };
+			let ended = false;
+			return {
+				setAttribute(key, value) {
+					record[key] = value;
+				},
+				end(endAttributes = {}) {
+					if (ended) return;
+					ended = true;
+					exportCounted(otelSpan({
+						traceId,
+						spanId: generateSpanId(),
+						parentSpanId: rootSpanId,
+						name,
+						startMs: opened,
+						endMs: Date.now(),
+						attributes: {
+							...record,
+							...endAttributes
+						},
+						status: STATUS_OK
+					}));
+				}
+			};
+		},
+		async finish(result) {
+			const root = branchSpan({
+				traceId,
+				spanId: rootSpanId,
+				name: "search.cell",
+				startTime: new Date(startMs).toISOString(),
+				branchId: work.nodeId,
+				arm: lane.name,
+				attributes: {
+					"tangle.search.id": work.searchId,
+					"tangle.search.cell_id": work.cellId,
+					"tangle.search.run_id": work.runId,
+					"tangle.search.task_id": work.taskId,
+					"tangle.search.split": work.split,
+					"tangle.search.stage": work.stage,
+					"tangle.search.attempt": work.attempt,
+					"tangle.search.lane": lane.name,
+					"tangle.search.lane_kind": lane.kind,
+					"tangle.search.outcome": result.outcome.status,
+					..."score" in result.outcome ? { [ATTR.score]: result.outcome.score } : {}
+				}
+			});
+			exportCounted(otelSpan({
+				traceId,
+				spanId: rootSpanId,
+				name: root.name,
+				startMs,
+				endMs: Date.now(),
+				attributes: root.attributes,
+				status: result.outcome.status === "errored" ? STATUS_ERROR : STATUS_OK
+			}));
+			if (ownsExporter) {
+				await exporter.shutdown();
+				const stats = exporter.stats();
+				written = stats.written;
+				dropped = stats.dropped;
+			}
+			return {
+				traceId,
+				execRunId: null,
+				spansWritten: written,
+				spansDropped: dropped
+			};
+		}
+	};
+}
+function otelSpan(input) {
+	const attributes = {};
+	for (const [key, value] of Object.entries(input.attributes)) if (typeof value === "number" || typeof value === "boolean") attributes[key] = value;
+	else if (typeof value === "string") attributes[key] = value.slice(0, MAX_ATTRIBUTE_CHARS);
+	return {
+		traceId: input.traceId,
+		spanId: input.spanId,
+		...input.parentSpanId ? { parentSpanId: input.parentSpanId } : {},
+		name: input.name,
+		kind: 1,
+		startTimeUnixNano: (BigInt(Math.floor(input.startMs)) * 1000000n).toString(),
+		endTimeUnixNano: (BigInt(Math.floor(Math.max(input.startMs, input.endMs))) * 1000000n).toString(),
+		attributes: toOtelAttributes(attributes),
+		status: { code: input.status }
+	};
+}
+//#endregion
 //#region src/improvement/search-method.ts
 /** Build Runtime's native search for `improve(profile, { method })`. */
 function searchMethod(options) {
@@ -2063,6 +2709,7 @@ function searchMethod(options) {
 	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,
@@ -2071,8 +2718,7 @@ function searchMethod(options) {
 		proposer,
 		maxExpansions: count("maxExpansions", options.maxExpansions, NaN, 0),
 		childrenPerProposal: count("childrenPerProposal", options.childrenPerProposal, 1, 1),
-		concurrency: count("concurrency", options.concurrency, 2, 1),
-		cellUsd: dollars("cellUsd", options.cellUsd) ?? 0,
+		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)
@@ -2087,14 +2733,15 @@ const SEARCH_METHOD_SOURCE = {
 		name: "agent-runtime.search-method.2026-09",
 		node: "an exact AgentProfile materialized from the baseline and one surface, content-addressed by canonicalAgentProfileDigest; a surface that does not materialize is a node addressed by its surface and refused",
 		edge: "the Interface diffs from the parent profile to the child, stored when they reproduce the child digest",
-		admission: "a candidate is refused when it does not materialize, declares training on a test task, fails the caller validator, or carries a credential or private value",
-		cell: "a one-cell runCampaign of the materialized profile in a directory addressed by its digest; a cached cell is read back, not run again",
+		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, trainScenarios, selectionScenarios, testScenarios, judges: _judges, surface: _surface, executionRef: _executionRef, validateCandidate: _validateCandidate, findings: _findings, skills: _skills, profileComponents: _profileComponents, minimumLift: _minimumLift, subject: _subject, costCeiling, costLedger: inputCostLedger, seed = 42, signal, ...campaignOptions } = opts;
+	const { method, claim: inputClaim, agent, trainScenarios, selectionScenarios, testScenarios, judges: _judges, surface: _surface, executionRef: _executionRef, validateCandidate: _validateCandidate, findings: _findings, skills: _skills, profileComponents: _profileComponents, minimumLift: _minimumLift, subject: _subject, costCeiling, costLedger: inputCostLedger, seed = 42, signal, 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");
@@ -2103,15 +2750,16 @@ async function runSearchImprovement(profile, opts) {
 		["selectionScenarios", selectionScenarios],
 		["testScenarios", testScenarios]
 	]) if (!Array.isArray(split) || split.length === 0) throw new ConfigError(`improve(): a search needs at least one of ${name}`);
-	const { allocation, policy } = method;
+	const { 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: method.concurrency
+			maxConcurrency: concurrency
 		}
 	});
 	const { evaluationRef } = prepared.identity;
@@ -2157,7 +2805,7 @@ async function runSearchImprovement(profile, opts) {
 	const reservedClaimUsd = Math.max(method.claimReserveUsd ?? 0, searchClaimReserveUsd({
 		testTasks: splits.test.length,
 		reps,
-		cellUsd: method.cellUsd
+		cellUsd: Math.max(...lanes.map((lane) => lane.cellUsd))
 	}));
 	const recorder = await SearchRecorder.open({
 		ledger: storage.kind === "filesystem" ? openSearchLedger({
@@ -2196,7 +2844,7 @@ async function runSearchImprovement(profile, opts) {
 			maxCells: null,
 			maxNodes: 1 + method.maxExpansions * method.childrenPerProposal,
 			deadline: method.deadline,
-			maxConcurrency: method.concurrency,
+			maxConcurrency: concurrency,
 			reservedClaimUsd: costCeiling === void 0 ? 0 : reservedClaimUsd
 		},
 		containment: null,
@@ -2219,7 +2867,32 @@ async function runSearchImprovement(profile, opts) {
 			};
 		}
 	};
-	const codec = profileCodec(prepared);
+	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,
@@ -2230,22 +2903,28 @@ async function runSearchImprovement(profile, opts) {
 		if (scenarioIds.has(scenario.id)) throw new ConfigError(`improve(): scenario '${scenario.id}' appears in more than one split`);
 		scenarioIds.add(scenario.id);
 	}
-	const lane = "in-process";
-	const executor = {
-		lanes: () => [{
-			name: lane,
-			capacity: method.concurrency,
-			costCap: "estimate",
-			cellUsd: method.cellUsd
-		}],
-		place: () => lane,
-		adopt: async () => null,
-		async run(work) {
+	const 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,
 				seed,
@@ -2253,21 +2932,35 @@ async function runSearchImprovement(profile, opts) {
 				storage,
 				runDir: `${searchDir}/nodes/${profileDigest.slice(7)}`,
 				dispatchRef: `improve:${evaluationRef}:${profileDigest}`,
-				dispatch: (scenario, ctx) => agent(nodeProfile, scenario, ctx),
+				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,
+				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`);
-			return campaignCellSearchResult(cell, {
+			return faultResult(campaignCellSearchResult(cell, {
 				execution,
-				lane: work.lane
-			});
+				lane: lane.name
+			}), cell.errorStage === "dispatch" ? fault : void 0);
 		}
-	};
+	});
 	const { proposer } = method;
 	const proposerSource = {
 		uri: `proposer:${proposer.kind}`,
@@ -2288,7 +2981,7 @@ async function runSearchImprovement(profile, opts) {
 		},
 		childrenPerProposal: method.childrenPerProposal,
 		async propose(request) {
-			const before = new Set(costLedger.list({ phase: proposalPhase }).map((r) => r.callId));
+			const tags = searchCallTags(searchId, { operation: request.operationId });
 			const state = await recorder.state();
 			const parents = request.parents.map(({ nodeId, artifact }) => ({
 				nodeId,
@@ -2305,13 +2998,16 @@ async function runSearchImprovement(profile, opts) {
 				populationSize: method.childrenPerProposal,
 				generation: request.expansion,
 				signal: request.signal,
-				costLedger,
+				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 }).filter((receipt) => !before.has(receipt.callId));
+			const fresh = costLedger.list({
+				phase: proposalPhase,
+				tags
+			});
 			return {
 				children: proposed.slice(0, method.childrenPerProposal).map((child) => isProposedCandidate(child) ? {
 					artifact: nodeOf(child.surface),
@@ -2337,12 +3033,13 @@ async function runSearchImprovement(profile, opts) {
 			return refusalText(error);
 		}
 		const paths = privateValuePaths([node.surface]);
-		return paths.length === 0 ? null : `the surface carries a credential or private value at ${paths.slice(0, 8).join(", ")}`;
+		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: nodeOf(prepared.baselineSurface),
+		root,
 		codec,
 		policy,
 		allocation,
@@ -2510,13 +3207,36 @@ function searchMethodDescriptor(method) {
 		proposer: method.proposer.kind,
 		maxExpansions: method.maxExpansions,
 		childrenPerProposal: method.childrenPerProposal,
-		concurrency: method.concurrency,
-		cellUsd: method.cellUsd,
+		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;
@@ -4140,6 +4860,6 @@ function sameOrderedValues(left, right) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
 //#endregion
-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 };
+export { applyRolloutPolicyToProfile as $, agentImprovementTargetInput as A, SearchEnvironmentFault as B, optimizationActivationReceiptFromMetadata as C, agentImprovementProfileSurfaceDigest as D, agentImprovementProfileDiffs as E, isAgentImprovementProfileSurface as F, subscriptionLane as G, isSearchEnvironmentFault as H, isAgentProfileMeasuredSurface as I, parseExecutionRef as J, assertCandidateValidator as K, improve as L, agentProfileImprovementStateDigest as M, assertProfileImprovementTargetsShareIdentity as N, agentImprovementProfileSurfaceInput as O, buildAgentImprovementActivationTargets as P, ROLLOUT_POLICY_EXTENSION as Q, createCommandProfileTrainer as R, createOptimizationActivationReceipt as S, AGENT_PROFILE_MEASURED_SURFACES as T, routerLane as U, dedicatedLane as V, sharedBoxLane as W, withMethodRuntimeControls as X, privateValuePaths as Y, rawTraceDistiller as Z, profilePolicyWithBudget as _, executeAgentCandidateExperimentCell as a, commandVerifier as at, profileTaskScenarioIdentity as b, requireSealedCandidateExperiment as c, verifyAgentImprovementActivation as d, normalizeRolloutPolicy as et, verifyAgentImprovementProposal as f, profileImprovementMetadata as g, createProfileImprovementCostLedger as h, createAgentImprovementProposal as i, agenticGenerator as it, agentImprovementTargetProfileDiffs as j, agentImprovementTargetDigest as k, reviewAgentImprovementProposal as l, verifyCandidateExecutionEvidence as m, createAgentImprovementActivation as n, serializeRolloutPolicy as nt, proposeAgentImprovement as o, defaultBuildPrompt as ot, verifyAgentImprovementReview as p, assertProfileTrainingIsHeldOut as q, createAgentImprovementMeasuredComparison as r, structuralRolloutPolicyFromProfile as rt, proposeAgentProfileImprovement as s, AgentCandidateExperimentCellExecutionError as t, parseRolloutPolicy as tt, runAgentCandidateExperiment as u, profilePreparationAccounting as v, AGENT_IMPROVEMENT_PROFILE_SURFACES as w, sealProfileImprovementBenchmark as x, profileStateDigest as y, searchMethod as z };
 
-//# sourceMappingURL=improvement-cycle-DXMU-2Y4.js.map
+//# sourceMappingURL=improvement-cycle-DCTCTmNl.js.map