@tangle-network/agent-runtime 0.337.1 → 0.338.0

package/dist/search-executor-DmgUm5p7.js

@@ -0,0 +1,1916 @@
+import { An as padSpanId, En as createOtelExporter, Kt as LEAF_CONTINUATION_TASK, La as promptFromAgentTurnInput, Mn as toOtelAttributes, On as generateSpanId, Ra as promptOptionsFromAgentTurnInput, Tn as createOpenInferenceFileExporter, jn as padTraceId, nn as openSlotGroup, ra as unavailableSignalOfFailure, ri as harnessInvocation, ta as unavailablePauseMs } from "./supervisor-CPG1I9UN.js";
+import { i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
+import { st as sleep, z as immutableCandidateValue } from "./sandbox-profile-compat-xSoVtdWw.js";
+import { a as concreteProfileModel, l as profileProviderModel } from "./model-policy-CyCUwHed.js";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
+import { CostAccountingIncompleteError, CostCeilingReachedError, costForTokenPricing, costForUsage } from "@tangle-network/agent-eval";
+import { createHash, 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 { 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/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 {
+		...cost,
+		costBound: {
+			unknownCalls,
+			unknownMaximumUsd,
+			totalMaximumUsd: summary.totalCostUsd + unknownMaximumUsd
+		}
+	};
+}
+/** 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
+	};
+	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}`
+	};
+	return {
+		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
+	};
+}
+/**
+* Decide a closed search: the ship rule, and the promotion when it ships.
+* `profileOf` returns the exact profile a node holds.
+*/
+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 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
+	};
+	const promotion = await searchPromotion(state, claim, input.profileOf);
+	if ("refused" in promotion) return {
+		decision: "hold",
+		reason: `${ruled.reason}; held: ${promotion.refused}`,
+		...lift
+	};
+	return {
+		...ruled,
+		...lift,
+		promotion
+	};
+}
+/**
+* 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.
+*/
+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}`
+	};
+	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 {
+		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: []
+			},
+			seed: header.policy.seed
+		}, { sealedAt: closed.occurredAt }),
+		decision
+	};
+}
+/**
+* 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 {
+		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-retry.ts
+/**
+* Attempts for one Sandbox API call that failed on the way to the box.
+*
+* Every call re-verifies the API key with the platform, and a burst of workers makes that check
+* time out: 8 of 64 workers failed with `502 platform_unavailable` (reason `platform_timeout`) in
+* one burst on 2026-09-24, and 3 more lost their transcript enumeration the same way. The check
+* refuses the request before it reaches the box, so repeating it is safe; five attempts over about
+* fifteen seconds rode out every such failure measured.
+*/
+const TRANSIENT_ATTEMPTS = 5;
+/** A failure that a repeated request can change: the platform, the gateway or the network. */
+function isTransientSandboxFailure(error) {
+	if (error === null || typeof error !== "object") return false;
+	const record = error;
+	if (typeof record.status === "number" && [
+		408,
+		425,
+		429,
+		500,
+		502,
+		503,
+		504
+	].includes(record.status)) return true;
+	const text = `${String(record.code ?? "")} ${String(record.name ?? "")} ${String(record.message ?? "")}`;
+	return /platform_unavailable|platform_timeout|platform_unreachable|fetch failed|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up|UND_ERR|bad gateway|gateway timeout/iu.test(text);
+}
+async function transientRetry(operation, options = {}) {
+	const delayMs = options.delayMs ?? 1e3;
+	for (let attempt = 1;; attempt += 1) try {
+		return await operation(attempt);
+	} catch (error) {
+		if (attempt >= TRANSIENT_ATTEMPTS || !isTransientSandboxFailure(error)) throw error;
+		options.signal?.throwIfAborted();
+		await sleep(delayMs * 2 ** (attempt - 1), options.signal);
+	}
+}
+/**
+* The Sandbox calls one worker makes, each repeated on a transient failure.
+*
+* A launch is repeated only after the pool confirms the box did not start it: a failed request
+* may have reached the box before its answer was lost, so the repeat first looks for a process
+* in the worker's own directory that this worker did not start yet, and adopts it. A process log
+* that breaks mid-stream is read again from the start, because the box replays a process's
+* buffered output, and the part already delivered is skipped.
+*/
+function resilientBox(box, delayMs) {
+	const retry = (operation) => transientRetry(operation, { delayMs });
+	return {
+		id: box.id,
+		exec: (command, options) => retry(() => box.exec(command, options)),
+		fs: {
+			read: (path) => retry(() => box.fs.read(path)),
+			write: (path, content) => retry(() => box.fs.write(path, content))
+		},
+		async spawnInDirectory(executable, args, options, known) {
+			return await transientRetry(async (attempt) => {
+				if (attempt > 1) {
+					const launched = (await box.process.list()).find((entry) => entry.cwd === options.cwd && entry.command === executable && !known.has(entry.pid));
+					const adopted = launched === void 0 ? null : await box.process.get(launched.pid);
+					if (adopted !== null) return adopted;
+				}
+				return await box.process.spawnExact(executable, args, options);
+			}, { delayMs });
+		},
+		async wait(process) {
+			return await retry(async () => {
+				try {
+					return await process.wait();
+				} catch (error) {
+					if (!isTransientSandboxFailure(error)) throw error;
+					const again = await box.process.get(process.pid);
+					if (again === null) throw error;
+					return await again.wait();
+				}
+			});
+		},
+		async *output(process, stream) {
+			let delivered = 0;
+			let source = process;
+			for (let attempt = 1;; attempt += 1) {
+				let seen = 0;
+				try {
+					for await (const chunk of source[stream]()) {
+						const fresh = seen + chunk.length <= delivered ? "" : chunk.slice(Math.max(0, delivered - seen));
+						seen += chunk.length;
+						if (fresh.length > 0) {
+							delivered += fresh.length;
+							yield fresh;
+						}
+					}
+					return;
+				} catch (error) {
+					if (attempt >= TRANSIENT_ATTEMPTS || !isTransientSandboxFailure(error)) throw error;
+					await sleep(delayMs * 2 ** (attempt - 1));
+					source = await retry(() => box.process.get(process.pid)) ?? source;
+				}
+			}
+		},
+		delete: () => retry(() => box.delete())
+	};
+}
+//#endregion
+//#region src/runtime/shared-box-worker.ts
+const HARNESS = "opencode";
+const SHARED_PROVIDER_NAME = "tangle-shared-box";
+const DEFAULT_EXEC_TIMEOUT_MS = 12e4;
+/** The request header the router records as a usage row's `clientName`. */
+const ROUTER_CLIENT_HEADER = "x-tangle-client";
+/**
+* The router client name of the worker that runs supervised node `nodeId`.
+*
+* The node id is already in the spawn journal, so a keeper joins a router row to a node without
+* a new record: the row whose `clientName` is `agent-runtime-node/<nodeId>` is that node's spend.
+*/
+function sharedWorkerClientName(nodeId) {
+	if (!/^[!-~]+$/u.test(nodeId)) throw new ValidationError("sharedWorkerClientName: a node id must be visible ASCII");
+	return `agent-runtime-node/${nodeId}`;
+}
+/**
+* Why a shared box cannot carry `profile`, or `undefined` when it can.
+*
+* A shared box carries a profile whose whole behavior reaches an opencode process through its own
+* working directory, its own configuration and the box's own model credential. Everything else
+* keeps a dedicated box: another harness, a model the box credential cannot reach, a replaced
+* system prompt, MCP servers, connections, hooks, subagents, extensions, tool grants, and any
+* resource the materializer does not lower into the worker's directory.
+*/
+function sharedBoxRefusal(profile) {
+	if (profile.model?.metadata?.credentialSource !== void 0) return "model.metadata.credentialSource requires a dedicated provider";
+	if (profile.harness !== "opencode") return `harness ${String(profile.harness)} is not ${HARNESS}`;
+	if (concreteProfileModel(profile) === void 0) return "profile names no concrete model";
+	if (profile.model?.provider === void 0) return "profile names no model provider";
+	if (profile.model?.reasoningEffort !== void 0) {
+		if (tryInvocation(profile) === void 0) return "model.reasoningEffort has no opencode variant";
+	}
+	if (profile.prompt?.systemPrompt !== void 0) return "prompt.systemPrompt replaces a system prompt";
+	for (const field of [
+		"mcp",
+		"connections",
+		"hooks",
+		"subagents",
+		"extensions",
+		"confidential",
+		"modes"
+	]) if (profile[field] !== void 0) return `profile declares ${field}`;
+	if (profile.tools !== void 0 && Object.keys(profile.tools).length > 0) return "profile grants tools";
+	const resources = profile.resources;
+	if (resources !== void 0) {
+		for (const field of [
+			"skills",
+			"agents",
+			"commands",
+			"tools"
+		]) if (resources[field] !== void 0) return `profile declares resources.${field}`;
+		for (const file of resources.files ?? []) if (file.resource.kind !== "inline") return `resource file ${file.path} is not inline`;
+		if (resources.instructions !== void 0 && typeof resources.instructions !== "string" && resources.instructions.kind !== "inline") return "resources.instructions is not inline";
+	}
+	let plan;
+	try {
+		plan = materializeProfile(profile, HARNESS);
+	} catch (error) {
+		return `opencode materialization failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	if (plan.unsupported.length > 0) return `opencode cannot carry ${plan.unsupported.map((row) => row.dimension).join(", ")}`;
+	if (Object.keys(plan.env).length > 0 || plan.flags.length > 0) return "profile needs launch environment or flags";
+	for (const file of plan.files) {
+		if (file.root === "agent") return `profile writes ${file.relPath} into the harness home`;
+		if ((file.secretSlots?.length ?? 0) > 0) return `profile file ${file.relPath} carries a secret`;
+		if (isUnsafeRelativePath(file.relPath)) return `profile file ${file.relPath} leaves its directory`;
+	}
+}
+function tryInvocation(profile) {
+	try {
+		return harnessInvocation(HARNESS, invocationProfile(profile), "probe").args;
+	} catch {
+		return;
+	}
+}
+/**
+* The profile the invocation table reads. The prompt reaches opencode through its configuration
+* and the model through the provider this placement declares, so only the reasoning effort is
+* left for the table to lower into `--variant`.
+*/
+function invocationProfile(profile) {
+	const { prompt: _prompt, model, ...rest } = profile;
+	return {
+		...rest,
+		...model?.reasoningEffort === void 0 ? {} : { model: { reasoningEffort: model.reasoningEffort } }
+	};
+}
+function isUnsafeRelativePath(path) {
+	return path.length === 0 || path.startsWith("/") || path.split("/").some((segment) => segment === ".." || segment === "");
+}
+function sharedBoxCapabilities() {
+	return {
+		profile: {
+			namedProfiles: false,
+			systemPrompt: {
+				...harnessSystemPromptIntents(HARNESS),
+				replace: false
+			},
+			instructions: true,
+			tools: false,
+			permissions: true,
+			mcp: false,
+			subagents: false,
+			resources: {
+				files: true,
+				instructions: true
+			},
+			runtimeUpdate: false,
+			validation: false
+		},
+		streaming: {
+			live: true,
+			replay: false,
+			detach: false,
+			turnIdempotency: false
+		},
+		sessions: {
+			continue: false,
+			list: false,
+			messages: false
+		},
+		workspace: {
+			read: true,
+			write: true,
+			exec: true,
+			git: false,
+			upload: false,
+			download: false
+		},
+		branching: {
+			checkpoint: false,
+			fork: false
+		},
+		placement: true,
+		usage: true,
+		confidential: false
+	};
+}
+function parseSharedWorkerProfile(input) {
+	const parsed = agentProfileSchema.safeParse(input.profile);
+	if (!parsed.success) throw new ValidationError("sharedBoxPlacement: an exact AgentProfile is required at create");
+	return parsed.data;
+}
+/**
+* A worker create carries only what a slot in a shared box can honor. Box-level settings belong
+* to the placement's own box options, and a per-worker request for them is refused rather than
+* dropped: a worker that asked for an environment variable, a repository or its own resources
+* would otherwise run without them and report nothing.
+*/
+function assertWorkerCreateInput(input) {
+	for (const key of [
+		"idempotencyKey",
+		"workspace",
+		"resources",
+		"runtimeAttachments",
+		"requestedId",
+		"egress",
+		"billingOwner"
+	]) if (input[key] !== void 0) throw new ValidationError(`sharedBoxPlacement: a shared worker cannot set ${key}`);
+	if (input.env !== void 0 && Object.keys(input.env).length > 0) throw new ValidationError("sharedBoxPlacement: a shared worker cannot set env");
+	if (input.secrets !== void 0 && Object.keys(input.secrets).length > 0) throw new ValidationError("sharedBoxPlacement: a shared worker cannot request secrets");
+	if (input.backend !== void 0 && input.backend !== "opencode") throw new ValidationError(`sharedBoxPlacement: backend ${input.backend} is not ${HARNESS}`);
+	for (const key of Object.keys(input.providerOptions ?? {})) if (key !== "sandboxCreateOptions") throw new ValidationError(`sharedBoxPlacement: a shared worker cannot set providerOptions.${key}`);
+	const box = input.providerOptions?.sandboxCreateOptions;
+	if (box === void 0) return;
+	if (box === null || typeof box !== "object" || Array.isArray(box)) throw new ValidationError("sharedBoxPlacement: sandboxCreateOptions must be an object");
+	for (const key of Object.keys(box)) if (![
+		"backend",
+		"metadata",
+		"name"
+	].includes(key)) throw new ValidationError(`sharedBoxPlacement: a shared worker cannot set ${key}`);
+	const projected = box;
+	if (projected.name !== void 0 && projected.name !== input.name) throw new ValidationError("sharedBoxPlacement: projected name must match the worker name");
+	if (projected.metadata !== void 0 && (input.metadata === void 0 || canonicalCandidateDigest(projected.metadata) !== canonicalCandidateDigest(input.metadata))) throw new ValidationError("sharedBoxPlacement: projected metadata must match worker metadata");
+	const backend = projected.backend;
+	if (backend?.type !== void 0 && backend.type !== "opencode") throw new ValidationError(`sharedBoxPlacement: backend ${backend.type} is not ${HARNESS}`);
+	for (const key of Object.keys(backend ?? {})) if (key !== "type" && key !== "profile") throw new ValidationError(`sharedBoxPlacement: a shared worker cannot set backend.${key}`);
+	if (backend?.profile !== void 0 && canonicalAgentProfileDigest(agentProfileSchema.parse(backend.profile)) !== canonicalAgentProfileDigest(parseSharedWorkerProfile(input))) throw new ValidationError("sharedBoxPlacement: projected profile must match the exact worker profile");
+}
+/** The environment one worker's processes see: its own directory, HOME and XDG roots. */
+function workerEnv(paths) {
+	return [
+		"OPENCODE_DISABLE_PROJECT_CONFIG=1",
+		`OPENCODE_CONFIG_DIR=${paths.dir}/.opencode`,
+		`PWD=${paths.dir}`,
+		`HOME=${paths.home}`,
+		`XDG_DATA_HOME=${paths.home}/.local/share`,
+		`XDG_CONFIG_HOME=${paths.home}/.config`,
+		`XDG_STATE_HOME=${paths.home}/.local/state`,
+		`XDG_CACHE_HOME=${paths.cache}`
+	];
+}
+async function createWorker(lease, root, createProfile, placement) {
+	const { clientName, unavailablePause } = placement;
+	const box = resilientBox(lease.box, placement.retryDelayMs);
+	const workerId = `w-${randomUUID()}`;
+	const paths = {
+		dir: `${root}/${workerId}`,
+		home: `${root}/${workerId}/.home`,
+		cache: `${root}/.cache`
+	};
+	const made = await box.exec(`mkdir -p '${paths.home}' '${paths.cache}'`, { timeoutMs: DEFAULT_EXEC_TIMEOUT_MS });
+	if ((made.exitCode ?? 1) !== 0) throw new Error(`sharedBoxPlacement: could not create ${paths.dir}: ${made.stderr ?? ""}`);
+	const env = workerEnv(paths);
+	let running;
+	let turnActive = false;
+	let released = false;
+	const started = /* @__PURE__ */ new Set();
+	const run = async (args, timeoutMs, extraEnv) => {
+		const process = await box.spawnInDirectory("/usr/bin/env", [...env, ...args], {
+			cwd: paths.dir,
+			...extraEnv === void 0 ? {} : { env: extraEnv },
+			timeoutMs
+		}, started);
+		started.add(process.pid);
+		return process;
+	};
+	const collect = async (process) => {
+		const [stdout, stderr, exitCode] = await Promise.all([
+			drain(box.output(process, "stdout")),
+			drain(box.output(process, "stderr")),
+			box.wait(process)
+		]);
+		return {
+			exitCode,
+			stdout,
+			stderr
+		};
+	};
+	const resolvePath = (path) => {
+		if (path.startsWith("/")) return path;
+		if (isUnsafeRelativePath(path)) throw new ValidationError(`sharedBoxPlacement: path ${path} leaves the worker directory`);
+		return `${paths.dir}/${path}`;
+	};
+	/**
+	* One turn: one or more opencode runs of the same session. The first runs `message`; a later run
+	* continues the session after the model provider refused a run for capacity.
+	*/
+	async function* turn(message, turnProfile, options) {
+		const signal = options?.signal;
+		const timeoutMs = options?.timeoutMs ?? 0;
+		const turnDeadline = timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
+		let sessionId;
+		const subagents = /* @__PURE__ */ new Set();
+		let refusalsInARow = 0;
+		let prompt = message;
+		for (let invocation = 1;; invocation += 1) {
+			const launch = await materializeWorker(box, paths, turnProfile, prompt, options?.backend?.model, clientName, sessionId);
+			signal?.throwIfAborted();
+			const remainingMs = turnDeadline === void 0 ? 0 : Math.max(1, turnDeadline - Date.now());
+			const process = await run(launch.args, remainingMs, { OPENCODE_CONFIG_CONTENT: launch.config });
+			running = process;
+			const onAbort = () => {
+				process.kill("SIGKILL", { tree: true }).catch(() => void 0);
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const stderr = drain(box.output(process, "stderr"));
+			const lines = lineReader();
+			const parsed = createOpencodeEventParser(launch.model);
+			let exitCode;
+			let errorText;
+			try {
+				for await (const chunk of box.output(process, "stdout")) for (const line of lines.push(chunk)) yield* parsed.line(line);
+				for (const line of lines.end()) yield* parsed.line(line);
+				exitCode = await box.wait(process);
+				errorText = (await stderr).slice(-4e3);
+			} finally {
+				signal?.removeEventListener("abort", onAbort);
+				running = void 0;
+			}
+			sessionId = parsed.sessionId() ?? sessionId;
+			for (const child of parsed.subagentSessionIds()) subagents.add(child);
+			const failure = parsed.failure(exitCode, errorText);
+			const refusal = failure === void 0 || unavailablePause === false || signal?.aborted ? void 0 : unavailableSignalOfFailure({ error: failure });
+			refusalsInARow = parsed.madeProgress() ? 1 : refusalsInARow + 1;
+			const pauseMs = refusal === void 0 || unavailablePause === false ? 0 : unavailablePauseMs(refusalsInARow, unavailablePause);
+			if (refusal === void 0 || turnDeadline !== void 0 && Date.now() + pauseMs >= turnDeadline) {
+				if (sessionId !== void 0) await exportSession(run, collect, paths, sessionId);
+				for (const child of subagents) if (child !== sessionId) await exportSession(run, collect, paths, child);
+				signal?.throwIfAborted();
+				yield* parsed.finish(exitCode, errorText, invocation);
+				return;
+			}
+			await sleep(pauseMs, signal);
+			signal?.throwIfAborted();
+			if (released) throw new ValidationError("sharedBoxPlacement: this worker was released");
+			prompt = sessionId === void 0 ? message : LEAF_CONTINUATION_TASK;
+		}
+	}
+	return {
+		id: `${box.id}/${workerId}`,
+		provider: SHARED_PROVIDER_NAME,
+		name: placement.name ?? workerId,
+		creation: "created",
+		capabilities: sharedBoxCapabilities(),
+		async status() {
+			return released ? "stopped" : "running";
+		},
+		metadata: {
+			...placement.metadata,
+			sharedBoxId: box.id,
+			workerId,
+			workerDir: paths.dir
+		},
+		async *stream(input) {
+			const message = promptFromAgentTurnInput(input);
+			if (typeof message !== "string") throw new ValidationError("sharedBoxPlacement: a shared worker requires a text prompt");
+			const options = promptOptionsFromAgentTurnInput(input);
+			if (released) throw new ValidationError("sharedBoxPlacement: this worker was released");
+			if (turnActive) throw new ValidationError("sharedBoxPlacement: a worker runs one turn at a time");
+			const turnProfile = options?.backend?.profile === void 0 ? createProfile : agentProfileSchema.parse(options.backend.profile);
+			if (canonicalAgentProfileDigest(turnProfile) !== canonicalAgentProfileDigest(createProfile) && sharedBoxRefusal(turnProfile) !== void 0) throw new ValidationError(`sharedBoxPlacement: ${sharedBoxRefusal(turnProfile)}`);
+			if (options?.backend?.type !== void 0 && options.backend.type !== "opencode") throw new ValidationError(`sharedBoxPlacement: backend ${options.backend.type} is not ${HARNESS}`);
+			turnActive = true;
+			try {
+				yield* turn(message, turnProfile, options);
+			} finally {
+				turnActive = false;
+			}
+		},
+		async exec(command, options) {
+			const process = await run([
+				"/bin/sh",
+				"-c",
+				command
+			], options?.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS);
+			return await collect(process);
+		},
+		async read(path) {
+			return await box.fs.read(resolvePath(path));
+		},
+		async write(path, content) {
+			await box.fs.write(resolvePath(path), content);
+		},
+		async placement() {
+			return {
+				kind: "sandbox",
+				sandboxId: box.id
+			};
+		},
+		async refresh() {},
+		async destroy() {
+			if (released) return;
+			released = true;
+			try {
+				await running?.kill("SIGKILL", { tree: true });
+				await box.exec(`rm -rf '${paths.dir}'`, { timeoutMs: DEFAULT_EXEC_TIMEOUT_MS });
+			} finally {
+				await lease.release();
+			}
+		}
+	};
+}
+async function drain(stream) {
+	let text = "";
+	for await (const chunk of stream) text += chunk;
+	return text;
+}
+function lineReader() {
+	let pending = "";
+	return {
+		push(chunk) {
+			pending += chunk;
+			const lines = pending.split("\n");
+			pending = lines.pop() ?? "";
+			return lines.filter((line) => line.trim().length > 0);
+		},
+		end() {
+			const rest = pending.trim();
+			pending = "";
+			return rest.length > 0 ? [rest] : [];
+		}
+	};
+}
+/**
+* Write the worker's materialized profile into its directory and build its launch.
+*
+* The files come from the same materializer the Sandbox sidecar uses, so a shared worker gets the
+* same instruction file, permissions and resource files a dedicated box would. The generated
+* `opencode.json` is passed as `OPENCODE_CONFIG_CONTENT` with its instruction paths made absolute,
+* because opencode resolves an instruction path in that variable against nothing.
+*/
+async function materializeWorker(box, paths, profile, task, turnModel, clientName, continueSession) {
+	const refusal = sharedBoxRefusal(profile);
+	if (refusal !== void 0) throw new ValidationError(`sharedBoxPlacement: ${refusal}`);
+	if (turnModel?.cliAuth !== void 0 || turnModel?.authFiles !== void 0 || turnModel?.authMode === "oauth") throw new ValidationError("sharedBoxPlacement: a shared worker cannot carry native credentials");
+	const plan = materializeProfile(profile, HARNESS);
+	let generated = {};
+	for (const file of plan.files) {
+		if (file.relPath === "opencode.json" && file.source === "generated") {
+			generated = JSON.parse(file.content);
+			continue;
+		}
+		if (continueSession === void 0) await box.fs.write(`${paths.dir}/${file.relPath}`, file.content);
+	}
+	const instructions = Array.isArray(generated.instructions) ? generated.instructions.map((entry) => typeof entry === "string" && !entry.startsWith("/") ? `${paths.dir}/${entry}` : entry) : void 0;
+	const providerId = profile.model.provider;
+	const modelId = profileProviderModel(profile);
+	const apiKeyEnv = typeof turnModel?.apiKeyEnv === "string" ? turnModel.apiKeyEnv : "OPENCODE_MODEL_API_KEY";
+	const baseURL = typeof turnModel?.baseUrl === "string" ? turnModel.baseUrl : "{env:OPENCODE_MODEL_BASE_URL}";
+	const config = {
+		$schema: "https://opencode.ai/config.json",
+		...generated,
+		...instructions === void 0 ? {} : { instructions },
+		permission: {
+			external_directory: {
+				"*": "deny",
+				"/tmp/**": "allow"
+			},
+			...generated.permission ?? {}
+		},
+		provider: { [providerId]: {
+			npm: "@ai-sdk/openai-compatible",
+			name: providerId,
+			options: {
+				baseURL,
+				apiKey: `{env:${apiKeyEnv}}`,
+				...clientName === void 0 ? {} : { headers: { [ROUTER_CLIENT_HEADER]: clientName } }
+			},
+			models: { [modelId]: { name: modelId } }
+		} }
+	};
+	const invocation = harnessInvocation(HARNESS, invocationProfile(profile), task, { dangerouslySkipPermissions: true });
+	const model = `${providerId}/${modelId}`;
+	if (continueSession !== void 0 && !/^[A-Za-z0-9_-]+$/u.test(continueSession)) throw new ValidationError(`sharedBoxPlacement: session id ${continueSession} is not opencode's`);
+	return {
+		args: [
+			invocation.command,
+			...invocation.args,
+			...continueSession === void 0 ? [] : ["--session", continueSession],
+			"--format",
+			"json",
+			"-m",
+			model
+		],
+		config: JSON.stringify(config),
+		model
+	};
+}
+/**
+* Save the harness's own record of the session where the transcript capture reads it.
+*
+* Current opencode keeps sessions in a SQLite database, which the capture cannot carry as text.
+* `opencode export` writes the same session as JSON.
+*/
+async function exportSession(run, collect, paths, sessionId) {
+	if (!SESSION_ID.test(sessionId)) return;
+	await collect(await run([
+		"/bin/sh",
+		"-c",
+		"mkdir -p \"$(dirname \"$2\")\" && exec opencode export \"$1\" > \"$2\"",
+		"export-session",
+		sessionId,
+		`${paths.home}/.local/share/opencode/export/${sessionId}.json`
+	], DEFAULT_EXEC_TIMEOUT_MS));
+}
+const SESSION_ID = /^[A-Za-z0-9_-]+$/u;
+/** A subagent's session id in a `task` result (`<task id="ses_…">`) or failure (`task_id: ses_…`). */
+const TASK_SESSION = /(?:<task id="|task_id: )(ses_[A-Za-z0-9]+)/u;
+/**
+* The session a harness subagent ran in, named by its parent's `task` tool part.
+*
+* opencode starts each subagent in a child session and refuses a nested one unless the
+* configuration raises `subagent_depth` above 1, so under the default the parent's parts name
+* every subagent session. A running part carries the id in `state.metadata.sessionId`; a finished
+* one also carries it in its output, and a failed one in its error.
+*/
+function subagentSessionOf(part) {
+	if (part.type !== "tool" || part.tool !== "task") return void 0;
+	const state = part.state;
+	if (state === void 0 || state === null || typeof state !== "object") return void 0;
+	const { metadata, output, error } = state;
+	const named = metadata !== null && typeof metadata === "object" ? metadata.sessionId : void 0;
+	if (typeof named === "string" && SESSION_ID.test(named)) return named;
+	for (const text of [output, error]) {
+		const match = typeof text === "string" ? TASK_SESSION.exec(text) : null;
+		if (match !== null) return match[1];
+	}
+}
+/**
+* Translate opencode's JSON event lines into events the provider executor reads.
+*
+* Every part becomes `message.part.updated`, which is how the sidecar forwards opencode parts, so
+* the existing trace and progress readers decode them unchanged. Each `step-finish` part also
+* becomes one canonical `llm_call` receipt with its token counts. opencode reports no dollar
+* receipt for a custom provider, so every receipt says the cost is unknown and Runtime prices the
+* tokens as an estimate instead of a bill.
+*/
+function createOpencodeEventParser(model) {
+	let sessionId;
+	let finalMessageId;
+	const textByMessage = /* @__PURE__ */ new Map();
+	const subagentSessions = /* @__PURE__ */ new Set();
+	const errors = [];
+	let malformed = 0;
+	let spentTokens = false;
+	const failureOf = (exitCode, stderr) => {
+		if (exitCode !== 0) {
+			const said = [...errors, stderr.trim().slice(-1e3)].filter((text) => text.length > 0);
+			return `opencode exited ${exitCode}${said.length > 0 ? `: ${said.join("; ")}` : ""}`;
+		}
+		return errors.length > 0 && finalMessageId === void 0 ? errors.join("; ") : void 0;
+	};
+	return {
+		sessionId: () => sessionId,
+		subagentSessionIds: () => [...subagentSessions],
+		/** Why this run failed, or `undefined` when it answered. */
+		failure: failureOf,
+		/** Whether this run spent any model tokens before it ended. */
+		madeProgress: () => spentTokens,
+		*line(raw) {
+			let event;
+			try {
+				event = JSON.parse(raw);
+			} catch {
+				malformed += 1;
+				return;
+			}
+			if (typeof event.sessionID === "string") sessionId ??= event.sessionID;
+			if (event.type === "error") {
+				const message = errorMessage(event.error);
+				errors.push(message);
+				yield {
+					type: "error",
+					data: { message }
+				};
+				return;
+			}
+			const part = event.part;
+			if (part === void 0 || part === null || typeof part !== "object") return;
+			const subagent = subagentSessionOf(part);
+			if (subagent !== void 0) subagentSessions.add(subagent);
+			yield {
+				type: "message.part.updated",
+				data: { part }
+			};
+			const messageId = typeof part.messageID === "string" ? part.messageID : void 0;
+			if (part.type === "text" && messageId !== void 0 && typeof part.text === "string") {
+				const texts = textByMessage.get(messageId) ?? [];
+				texts.push(part.text);
+				textByMessage.set(messageId, texts);
+			}
+			if (part.type === "step-finish") {
+				if (messageId !== void 0) finalMessageId = messageId;
+				const receipt = stepReceipt(part, model);
+				if (receipt !== void 0) {
+					const data = receipt.data;
+					if ((data?.tokensIn ?? 0) > 0 || (data?.tokensOut ?? 0) > 0) spentTokens = true;
+					yield receipt;
+				}
+			}
+		},
+		/** The turn's terminal frames, from its last run. `runs` counts the runs of the session. */
+		*finish(exitCode, stderr, runs = 1) {
+			const finalText = (finalMessageId === void 0 ? void 0 : textByMessage.get(finalMessageId)?.join("")) ?? "";
+			const failure = failureOf(exitCode, stderr);
+			const counted = {
+				...malformed > 0 ? { malformedLines: malformed } : {},
+				...runs > 1 ? { sessionRuns: runs } : {}
+			};
+			if (failure !== void 0) {
+				yield {
+					type: "result",
+					data: {
+						success: false,
+						status: "failed",
+						error: failure,
+						finalText,
+						...counted
+					}
+				};
+				yield {
+					type: "done",
+					data: { outcome: { type: "failed" } }
+				};
+				return;
+			}
+			yield {
+				type: "result",
+				data: {
+					success: true,
+					finalText,
+					...counted
+				}
+			};
+			yield {
+				type: "done",
+				data: { outcome: { type: "completed" } }
+			};
+		}
+	};
+}
+function stepReceipt(part, model) {
+	const tokens = part.tokens;
+	if (tokens === void 0 || tokens === null || typeof tokens !== "object") return void 0;
+	const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+	const cache = tokens.cache ?? {};
+	const input = count(tokens.input);
+	const output = count(tokens.output);
+	const reasoning = count(tokens.reasoning) ?? 0;
+	const cacheRead = count(cache.read) ?? 0;
+	const cacheWrite = count(cache.write) ?? 0;
+	const known = input !== void 0 && output !== void 0;
+	return {
+		type: "llm_call",
+		...typeof part.id === "string" ? { id: part.id } : {},
+		usageMode: "delta",
+		...known ? { usage: {
+			inputTokens: input + cacheRead + cacheWrite,
+			outputTokens: output + reasoning,
+			...reasoning > 0 ? { reasoningTokens: reasoning } : {}
+		} } : {},
+		data: {
+			usageMode: "delta",
+			model,
+			...known ? {
+				tokensIn: input + cacheRead + cacheWrite,
+				tokensOut: output + reasoning,
+				...reasoning > 0 ? { reasoningTokens: reasoning } : {}
+			} : { tokensKnown: false },
+			costKnown: false
+		}
+	};
+}
+function errorMessage(error) {
+	if (typeof error === "string") return error;
+	if (error !== null && typeof error === "object") {
+		const record = error;
+		const data = record.data;
+		const text = typeof data?.message === "string" ? data.message : typeof record.message === "string" ? record.message : typeof record.name === "string" ? record.name : "opencode reported an error";
+		const status = data?.statusCode;
+		return typeof status === "number" && Number.isSafeInteger(status) ? `${text} (status code ${status})` : text;
+	}
+	return "opencode reported an error";
+}
+//#endregion
+//#region src/runtime/shared-box.ts
+/**
+* Shared-box placement: many harness workers in one Sandbox box, each as its own process.
+*
+* The default provider placement gives every worker its own Sandbox box. A box costs a create
+* call, a sidecar, an egress proxy, a preview link and a memory reservation sized for the box,
+* while one opencode worker uses about half a gigabyte. This module packs workers into a small
+* pool of boxes instead. Each worker runs `opencode run` as a separate process with its own
+* working directory and its own HOME, so each worker has its own harness session, its own
+* materialized profile and its own transcript files.
+*
+* Why processes and not sidecar sessions: the sidecar serves every session in one box from one
+* workspace and writes each session's profile into the same files. Measured 2026-09-24 on
+* sandbox-ff52a989e7c9: eight concurrent sessions with different instructions, and seven of eight
+* answered with another session's instructions. A process with its own directory, its own HOME and
+* `OPENCODE_DISABLE_PROJECT_CONFIG` reads only its own configuration: sixteen of sixteen concurrent
+* workers answered with their own instructions and wrote only into their own directory.
+*
+* The boundary is cooperative, not a security boundary. Every worker runs as the same Linux user,
+* so a worker can read a co-tenant's files through its shell. A profile that writes a repository,
+* runs untrusted code, holds a credential of its own, or must stay blind to its siblings keeps a
+* dedicated box: {@link SharedBoxPlacement.refusal} names the profile features this placement
+* cannot carry, and Runtime then uses the dedicated provider.
+*
+* A worker whose model provider refuses a turn for capacity keeps its process's session and
+* directory, pauses by the driver's rule, and continues the same opencode session, the way a
+* dedicated leaf does (`ProviderExecutorOptions.unavailablePause`). Measured 2026-09-24: 15 of 23
+* down children of play anomaly-referee-v3d ended on `provider_quota_exhausted`, and opencode
+* itself gives up on a refused model after about 70 seconds of its own retries.
+*
+* The workers of one box share the box's router key. Each worker names itself to the router with
+* the `x-tangle-client` header, which the router stores as `clientName` on every usage row, so a
+* keeper can price one worker from the key's per-client rows (`tangle-admin router-spend --key
+* <box key>`). A request without the header stays charged to the box.
+*
+* `workersPerBox` is the one structural cap, and it protects the box. A Tangle box has a fixed
+* 512-task pids limit. An idle box uses about 118 tasks and one opencode worker about 34, so
+* twelve workers reach the limit. At that limit the sidecar's own process spawn fails with EAGAIN
+* and the sidecar restarts, which ends every worker in the box (measured on the same box: 28
+* workers crashed the sidecar twice; 16 workers crashed it once).
+*/
+/**
+* The most workers one default box carries at once.
+*
+* It keeps a worker count that the 512-task pids limit of a Tangle box can hold with headroom
+* for the sidecar's own processes and the workers' tool shells: 118 idle tasks plus 8 workers at
+* about 34 tasks each is 390. Memory is not the binding limit: 8 workers used about 4 GB in a
+* 16 GB box. Raise it only for a box whose pids limit was raised with it.
+*/
+const DEFAULT_SHARED_BOX_WORKERS = 8;
+/** The box shape the default placement creates: memory for 8 workers at about 0.5 GB each plus
+*  the sidecar, and 4 cores, because the workers wait on the model most of the time. */
+const DEFAULT_SHARED_BOX_RESOURCES = Object.freeze({
+	cpuCores: 4,
+	memoryMB: 8192
+});
+const DEFAULT_WORKER_ROOT = "/home/agent/workers";
+/**
+* Place accepted workers as processes in a pool of shared Sandbox boxes.
+*
+* The pool fills a box before it creates the next one and deletes a box when its last worker
+* releases it. Runtime reaches this placement through `createExecutor({ backend: 'provider',
+* shared })`: a profile that {@link SharedBoxPlacement.refusal} accepts runs here, and every other
+* profile keeps the dedicated provider.
+*/
+function sharedBoxPlacement(options) {
+	const workersPerBox = options.workersPerBox ?? 8;
+	if (!Number.isSafeInteger(workersPerBox) || workersPerBox < 1) throw new ValidationError("sharedBoxPlacement: workersPerBox must be a positive integer");
+	const workerRoot = options.workerRoot ?? DEFAULT_WORKER_ROOT;
+	if (!workerRoot.startsWith("/") || isUnsafeRelativePath(workerRoot.slice(1))) throw new ValidationError("sharedBoxPlacement: workerRoot must be an absolute, normalized path");
+	const boxOptions = {
+		resources: { ...DEFAULT_SHARED_BOX_RESOURCES },
+		...options.box ?? {}
+	};
+	if (boxOptions.backend !== void 0) throw new ValidationError("sharedBoxPlacement: box.backend is owned by Runtime");
+	const identity = {
+		id: "shared-box",
+		digest: canonicalCandidateDigest({
+			kind: "shared-box-placement.v1",
+			harness: HARNESS,
+			workersPerBox,
+			workerRoot,
+			box: publicBoxOptions(boxOptions)
+		})
+	};
+	const retryDelayMs = options.retryDelayMs ?? 1e3;
+	const pool = createBoxPool(options.client, boxOptions, workersPerBox, retryDelayMs);
+	const providerFor = (worker = {}) => {
+		const clientName = worker.nodeId === void 0 ? void 0 : sharedWorkerClientName(worker.nodeId);
+		return {
+			name: SHARED_PROVIDER_NAME,
+			capabilities: sharedBoxCapabilities,
+			async create(input) {
+				const profile = parseSharedWorkerProfile(input);
+				const refusal = sharedBoxRefusal(profile);
+				if (refusal !== void 0) throw new ValidationError(`sharedBoxPlacement: ${refusal}`);
+				assertWorkerCreateInput(input);
+				input.signal?.throwIfAborted();
+				const lease = await pool.acquire();
+				try {
+					input.signal?.throwIfAborted();
+					return await createWorker(lease, workerRoot, profile, {
+						retryDelayMs,
+						clientName,
+						name: input.name,
+						metadata: input.metadata,
+						unavailablePause: options.unavailablePause ?? {}
+					});
+				} catch (error) {
+					await lease.release();
+					throw error;
+				}
+			}
+		};
+	};
+	return {
+		providerFor,
+		identity,
+		refusal: sharedBoxRefusal,
+		stats: () => pool.stats(),
+		close: () => pool.close()
+	};
+}
+function publicBoxOptions(box) {
+	const { env, secrets, ...rest } = box;
+	return {
+		...rest,
+		...env === void 0 ? {} : { environmentVariableNames: Object.keys(env).sort() },
+		...secrets === void 0 ? {} : { secrets }
+	};
+}
+function createBoxPool(client, boxOptions, workersPerBox, retryDelayMs) {
+	const poolId = randomUUID();
+	const boxes = [];
+	const history = [];
+	let seq = 0;
+	let placed = 0;
+	let peak = 0;
+	let closing = false;
+	const retire = async (entry) => {
+		if (entry.retired) return void 0;
+		entry.retired = true;
+		const index = boxes.indexOf(entry);
+		if (index >= 0) boxes.splice(index, 1);
+		let handle;
+		try {
+			handle = await entry.ready;
+		} catch {
+			return;
+		}
+		try {
+			await transientRetry(() => handle.delete(), { delayMs: retryDelayMs });
+			entry.deleted = true;
+			return {
+				boxId: handle.id,
+				deleted: true
+			};
+		} catch (error) {
+			return {
+				boxId: handle.id,
+				deleted: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	return {
+		async acquire() {
+			if (closing) throw new ValidationError("sharedBoxPlacement: the placement is closed");
+			let entry = boxes.find((candidate) => !candidate.retired && candidate.workers < workersPerBox);
+			if (entry === void 0) {
+				const boxSeq = seq++;
+				const request = {
+					...boxOptions,
+					name: boxOptions.name ?? `shared-box-${poolId.slice(0, 8)}-${boxSeq}`,
+					idempotencyKey: `shared-box-${poolId}-${boxSeq}`,
+					backend: {
+						type: HARNESS,
+						profile: {
+							name: "shared-box",
+							harness: HARNESS
+						}
+					}
+				};
+				const requestedAt = Date.now();
+				const created = {
+					seq: boxSeq,
+					ready: transientRetry(() => client.create(request), { delayMs: retryDelayMs }).then((box) => box),
+					workers: 0,
+					served: 0,
+					retired: false,
+					deleted: false
+				};
+				created.ready.then((box) => {
+					created.id = box.id;
+					created.createMs = Date.now() - requestedAt;
+				}, () => {
+					const index = boxes.indexOf(created);
+					if (index >= 0) boxes.splice(index, 1);
+					created.retired = true;
+				});
+				boxes.push(created);
+				history.push(created);
+				entry = created;
+			}
+			const leased = entry;
+			leased.workers += 1;
+			leased.served += 1;
+			placed += 1;
+			peak = Math.max(peak, leased.workers);
+			let box;
+			try {
+				box = await leased.ready;
+			} catch (error) {
+				leased.workers -= 1;
+				throw error;
+			}
+			let released = false;
+			return {
+				box,
+				async release() {
+					if (released) return;
+					released = true;
+					leased.workers -= 1;
+					if (leased.workers === 0 && !closing) await retire(leased);
+				}
+			};
+		},
+		stats() {
+			return {
+				boxesCreated: history.length,
+				boxesLive: history.filter((entry) => !entry.retired).length,
+				workersPlaced: placed,
+				workersLive: history.reduce((sum, entry) => sum + entry.workers, 0),
+				peakWorkersPerBox: peak,
+				boxes: history.filter((entry) => entry.id !== void 0).map((entry) => ({
+					id: entry.id,
+					workersServed: entry.served,
+					deleted: entry.deleted,
+					createMs: entry.createMs ?? 0
+				}))
+			};
+		},
+		async close() {
+			closing = true;
+			return (await Promise.all(history.map((entry) => retire(entry)))).filter((receipt) => receipt !== void 0);
+		}
+	};
+}
+//#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 { recordCell, ...measured } = await options.runAttempt({
+					work,
+					lane,
+					context,
+					costLedger: attemptLedger(options.costLedger, lane, tags),
+					span: trace.span
+				});
+				const traceRef = await trace.finish(measured);
+				const execRunId = measured.traceRef && "execRunId" in measured.traceRef ? measured.traceRef.execRunId : null;
+				result = {
+					...measured,
+					accounting: attemptAccounting(options.costLedger, lane, tags),
+					queueMs,
+					placement: {
+						lane: lane.name,
+						boxId: measured.placement?.boxId ?? null
+					},
+					traceRef: execRunId && "traceId" in traceRef ? {
+						...traceRef,
+						execRunId
+					} : traceRef
+				};
+				if (recordCell && result.outcome.status !== "errored") result.runRecord = await recordCell(result);
+			} 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
+export { sharedWorkerClientName as _, reconcileInterruptedSearchCalls as a, improveSearchCost as b, searchExecutor as c, taggedLedger as d, DEFAULT_SHARED_BOX_RESOURCES as f, sharedBoxRefusal as g, ROUTER_CLIENT_HEADER as h, isSearchEnvironmentFault as i, sharedBoxLane as l, sharedBoxPlacement as m, assertSearchLanes as n, routerLane as o, DEFAULT_SHARED_BOX_WORKERS as p, dedicatedLane as r, searchCallTags as s, SearchEnvironmentFault as t, subscriptionLane as u, decideClosedSearch as v, runtimeShipDecision as x, decideSearchImprovement as y };
+
+//# sourceMappingURL=search-executor-DmgUm5p7.js.map