@tangle-network/agent-runtime 0.116.0 → 0.119.0

package/dist/{supervisor-BBbPBXpe.js → supervisor-CpT9yAxL.js}

@@ -1,12 +1,13 @@
 import { c as RuntimeRunStateError, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { n as addTokenUsage, p as zeroTokenUsage } from "./util-Cc9g9Y-o.js";
-import { a as contentAddress, c as replaySpawnTree, o as materializeTreeView, s as pendingWaits } from "./spawn-journal-DCPbicXB.js";
+import { S as detachedSnapshot, _ as captureWorkerTraceEvidence, c as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, m as nestedDriverTreeRoot, o as materializeTreeView, p as driverRuntime, s as pendingWaits, x as contentAddress } from "./spawn-journal-IeXpidO2.js";
+import { f as zeroTokenUsage, t as addTokenUsage } from "./util-MVgdwuIS.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, agentProfileSchema, canonicalCandidateDigest, profileMaterializationAxes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { createHash, randomUUID } from "node:crypto";
-import { applyWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
+import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
 import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, realpath, rm, symlink, writeFile } from "node:fs/promises";
-import { constants, createReadStream } from "node:fs";
+import { appendFileSync, constants, createReadStream } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
@@ -139,20 +140,6 @@ function collectStringLeaves(value, output) {
 *
 * @experimental
 */
-const codexReasoningEffort = {
-	none: "none",
-	minimal: "minimal",
-	low: "low",
-	medium: "medium",
-	high: "high",
-	xhigh: "xhigh",
-	ultracode: "xhigh"
-};
-function codexReasoningArgs(reasoningEffort) {
-	const mapped = codexReasoningEffort[reasoningEffort];
-	if (mapped === void 0) throw new Error(`harnessInvocation: unsupported Codex reasoning effort ${String(reasoningEffort)}`);
-	return ["-c", `model_reasoning_effort="${mapped}"`];
-}
 /**
 * Default per-harness command + arg shape. `buildArgs` takes ONLY the task prompt and
 * emits the prompt-only invocation (no model, no system prompt) — the safe default shape
@@ -160,25 +147,94 @@ function codexReasoningArgs(reasoningEffort) {
 * the harness's selector flag (every supported harness takes `-m <model>`). The §1.5
 * profile-aware mapper `harnessInvocation` composes these to thread the full
 * supervisor-authored profile (systemPrompt + model) into argv.
+*
+* Every per-harness difference is a FIELD on this row, never a test on the harness name at a
+* call site: adding harness N+1 is one entry here, and a caller asking for a capability the
+* row does not declare is refused up front instead of silently losing the request.
 */
 const HARNESS_INVOCATIONS = {
-	claude: {
+	"claude-code": {
 		command: "claude",
 		buildArgs: (taskPrompt) => ["-p", taskPrompt],
-		modelArgs: (model) => ["-m", model]
+		modelArgs: (model) => ["-m", model],
+		reasoning: {
+			levels: {
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "max"
+			},
+			args: (level) => ["--effort", level]
+		},
+		permissionBypassArgs: () => ["--dangerously-skip-permissions"]
 	},
 	codex: {
 		command: "codex",
 		buildArgs: (taskPrompt) => ["exec", taskPrompt],
 		modelArgs: (model) => ["-m", model],
-		reasoningArgs: codexReasoningArgs
+		reasoning: {
+			levels: {
+				none: "none",
+				minimal: "minimal",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "xhigh"
+			},
+			args: (level) => ["-c", `model_reasoning_effort="${level}"`]
+		},
+		permissionBypassArgs: () => [
+			"--sandbox",
+			"workspace-write",
+			"-c",
+			"approval_policy=\"never\""
+		]
 	},
 	opencode: {
 		command: "opencode",
 		buildArgs: (taskPrompt) => ["run", taskPrompt],
-		modelArgs: (model) => ["-m", model]
+		modelArgs: (model) => ["-m", model],
+		reasoning: {
+			levels: {
+				minimal: "minimal",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "max"
+			},
+			args: (level) => ["--variant", level]
+		}
 	}
 };
+/** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
+*  other harness enumeration reads, so adding a row above is the only edit a new harness needs. */
+const LOCAL_HARNESSES = Object.keys(HARNESS_INVOCATIONS);
+/** The harness a caller gets when it expresses no preference. A composition-root default, not a
+*  capability claim: one constant so the several entry points cannot drift apart. */
+const DEFAULT_LOCAL_HARNESS = "claude-code";
+/** The CLI binary a harness id runs. The two are NOT the same string (`claude-code` runs `claude`),
+*  so anything spawning a harness — a version probe, a login check — reads it from here rather than
+*  passing the harness id as a command. */
+function localHarnessExecutable(harness) {
+	return HARNESS_INVOCATIONS[harness].command;
+}
+/**
+* Whether the harness's native control can express this reasoning effort. Admission checks read
+* this so a profile the invocation would later refuse is rejected BEFORE any workspace state is
+* created, against the same table that emits the argv.
+*/
+function harnessSupportsReasoningEffort(harness, reasoningEffort) {
+	return HARNESS_INVOCATIONS[harness].reasoning?.levels[reasoningEffort] !== void 0;
+}
+function harnessReasoningArgs(harness, reasoningEffort) {
+	const reasoning = HARNESS_INVOCATIONS[harness].reasoning;
+	const level = reasoning?.levels[reasoningEffort];
+	if (reasoning === void 0 || level === void 0) throw new Error(`harnessInvocation: ${harness} cannot express reasoning effort ${String(reasoningEffort)}`);
+	return reasoning.args(level);
+}
 const CODEX_REPRODUCIBLE_ARGS = [
 	"--ephemeral",
 	"--ignore-rules",
@@ -204,8 +260,9 @@ const CODEX_REPRODUCIBLE_ARGS = [
 	"--strict-config"
 ];
 function buildHarnessArgs(harness, taskPrompt, options = {}) {
-	const args = HARNESS_INVOCATIONS[harness].buildArgs(taskPrompt);
-	if (harness === "claude" && options.dangerouslySkipPermissions) args.push("--dangerously-skip-permissions");
+	const invocation = HARNESS_INVOCATIONS[harness];
+	const args = invocation.buildArgs(taskPrompt);
+	if (options.dangerouslySkipPermissions && !options.codexReproducible) args.push(...invocation.permissionBypassArgs?.() ?? []);
 	if (options.codexReproducible) {
 		if (harness !== "codex") throw new Error("harnessInvocation: codexReproducible requires the Codex harness");
 		args.push(...CODEX_REPRODUCIBLE_ARGS);
@@ -248,7 +305,7 @@ function harnessInvocation(harness, profile, taskPrompt, options = {}) {
 	const model = profile.model?.default;
 	if (typeof model === "string" && model.length > 0) args.push(...invocation.modelArgs(model));
 	const reasoningEffort = profile.model?.reasoningEffort;
-	if (reasoningEffort !== void 0 && invocation.reasoningArgs) args.push(...invocation.reasoningArgs(reasoningEffort));
+	if (reasoningEffort !== void 0) args.push(...harnessReasoningArgs(harness, reasoningEffort));
 	return {
 		command: invocation.command,
 		args,
@@ -1140,6 +1197,255 @@ function naturalNumber(value, field) {
 	return value;
 }
 //#endregion
+//#region src/agent/profile-materialization.ts
+const KNOWN_AXIS_SET = new Set(AGENT_PROFILE_MATERIALIZATION_AXES);
+/**
+* Compound AgentProfile properties and the canonical leaves they cover.
+*
+* agent-interface publishes two axis vocabularies, and this module has to sit between them:
+* `profileMaterializationAxes` emits canonical LEAVES, while `changedAgentProfileAxes` emits
+* DIFF axes, which are compound property names (`model`, `prompt`, `resources`, `identity`) for
+* everything except the already-scalar properties. A changed-axis input is therefore expanded
+* through this map, so both producers compose with this validator.
+*
+* A CONTRACT may still only name leaves. Expanding an input is safe — it asks about more, never
+* less — whereas letting a contract claim a parent is what silently swallows a dropped child.
+*/
+const compoundAxisLeaves = {
+	identity: [
+		"name",
+		"description",
+		"version",
+		"tags"
+	],
+	prompt: ["systemPrompt", "instructions"],
+	model: [
+		"modelDefault",
+		"modelSmall",
+		"modelProvider",
+		"modelReasoningEffort",
+		"modelMetadata"
+	],
+	resources: [
+		"files",
+		"resourceTools",
+		"skills",
+		"resourceAgents",
+		"commands",
+		"resourceInstructions",
+		"resourceFailOnError"
+	],
+	mcpConnections: ["mcp"]
+};
+/** Materialization contract for a run path that executes every canonical AgentProfile leaf. */
+const fullProfileMaterialization = defineProfileMaterializationContract({
+	name: "full-profile-execution",
+	axes: AGENT_PROFILE_MATERIALIZATION_AXES
+});
+/**
+* Materialization contract for an intentionally limited prompt-and-model execution path.
+* Identity, harness, and metadata are control fields consumed for naming, placement,
+* authorization, and durable attribution; they are carried without adding worker behavior.
+* Every behavioral axis other than prompt and model remains unsupported.
+*/
+const promptModelProfileMaterialization = defineProfileMaterializationContract({
+	name: "prompt-model-execution",
+	axes: [
+		"name",
+		"systemPrompt",
+		"instructions",
+		"modelDefault",
+		"harness",
+		"metadata"
+	]
+});
+/**
+* Materialization contract for a local coding CLI in an isolated git worktree.
+* The shared workspace materializer carries native tools, permissions, MCP, hooks, subagents,
+* modes, and file-backed resources when the selected CLI supports their exact values.
+* `resourceFailOnError` is carried: it is the fail-closed policy the pre-worktree resource
+* RESOLUTION step (`resolveAgentProfileResources`) applies to remote profile resources. Runtime
+* placement concerns (hub connections and confidential execution), provider-native extensions,
+* and unused model hints are deliberately absent so they fail before a worktree or executor is
+* created rather than being mistaken for an effective candidate change.
+*/
+const worktreeCliProfileMaterialization = defineProfileMaterializationContract({
+	name: "worktree-cli-execution",
+	axes: [
+		"name",
+		"systemPrompt",
+		"instructions",
+		"modelDefault",
+		"modelReasoningEffort",
+		"harness",
+		"permissions",
+		"tools",
+		"mcp",
+		"subagents",
+		"files",
+		"resourceTools",
+		"skills",
+		"resourceAgents",
+		"commands",
+		"resourceInstructions",
+		"resourceFailOnError",
+		"hooks",
+		"modes",
+		"metadata"
+	]
+});
+/** Materialization contract for a raw process path that carries only control/identity fields. */
+const controlProfileMaterialization = defineProfileMaterializationContract({
+	name: "control-only-execution",
+	axes: [
+		"name",
+		"harness",
+		"metadata"
+	]
+});
+/** Materialization contract for an injected inference function whose surrounding driver still
+* applies the profile prompt, name, placement, and metadata, but not model selection. */
+const promptControlProfileMaterialization = defineProfileMaterializationContract({
+	name: "prompt-control-execution",
+	axes: [
+		"name",
+		"systemPrompt",
+		"instructions",
+		"harness",
+		"metadata"
+	]
+});
+/**
+* Materialization contract for `createSandboxAct`.
+*
+* `createSandboxAct` hands the whole `AgentProfile` to the sandbox as `backend.profile`, so every
+* profile leaf crosses the boundary. `buildBackendOptions` resolves the runner from an explicit
+* `sandboxOverrides.backend.type`, then `profile.metadata.backendType`, then `profile.harness`,
+* so a candidate that changes only `harness` runs on the harness it declares — and one declaring
+* a harness the sandbox cannot run throws rather than running elsewhere and reporting success.
+*/
+const sandboxActProfileMaterialization = defineProfileMaterializationContract({
+	name: "createSandboxAct",
+	axes: fullProfileMaterialization.axes
+});
+/** Materialization contract for a run path that only injects prompt text. */
+const promptOnlyProfileMaterialization = defineProfileMaterializationContract({
+	name: "prompt-only-message",
+	axes: ["systemPrompt", "instructions"]
+});
+/**
+* Materialization contract for a run path that injects prompt text plus inline resources.
+*
+* `resourceFailOnError` is absent: it is a resolution POLICY the attaching path would have to
+* enforce, and inlining resource content does not carry it.
+*/
+const promptResourceProfileMaterialization = defineProfileMaterializationContract({
+	name: "prompt-resource-attachment",
+	axes: [
+		"systemPrompt",
+		"instructions",
+		"files",
+		"resourceTools",
+		"skills",
+		"resourceAgents",
+		"commands",
+		"resourceInstructions"
+	]
+});
+/** Define the profile axes a concrete run path actually carries into execution. */
+function defineProfileMaterializationContract(options) {
+	const name = options.name.trim();
+	if (!name) throw new ValidationError("defineProfileMaterializationContract: name is required");
+	return {
+		name,
+		axes: normalizeContractAxes(options.axes, `${name}.axes`)
+	};
+}
+/** Return every changed profile axis that the selected run path would drop. */
+function validateProfileMaterialization(options) {
+	const changedAxes = normalizeChangedAxes(options.changedAxes, "changedAxes");
+	const supported = new Set(normalizeContractAxes(options.contract.axes, `${options.contract.name}.axes`));
+	const issues = [];
+	for (const axis of changedAxes) {
+		if (isAxisSupported(axis, supported)) continue;
+		issues.push({
+			contract: options.contract.name,
+			axis,
+			reason: "unsupported-axis",
+			supportedAxes: [...supported]
+		});
+	}
+	return issues;
+}
+/** Throw when a candidate changes axes the selected run path cannot carry. */
+function assertProfileMaterialization(options) {
+	const issues = validateProfileMaterialization(options);
+	if (issues.length === 0) return;
+	throw new ValidationError(renderProfileMaterializationIssues(issues, options.context));
+}
+/** Format profile-axis drop issues into a concise operator-facing error. */
+function renderProfileMaterializationIssues(issues, context) {
+	if (issues.length === 0) return "";
+	const contract = issues[0]?.contract ?? "<unknown>";
+	const prefix = context ? `${context}: ` : "";
+	const droppedAxes = issues.map((issue) => issue.axis).join(", ");
+	const supportedAxes = issues[0]?.supportedAxes.join(", ") || "<none>";
+	return [
+		`${prefix}profile materialization would drop axis changes on "${contract}": ${droppedAxes}.`,
+		`Supported axes: ${supportedAxes}.`,
+		"Use a run path that carries those AgentProfile axes, or remove them from the candidate."
+	].join("\n");
+}
+/** Contract side: leaves (or `custom:`) only. A parent claim would hide a dropped child. */
+function normalizeContractAxes(axes, label) {
+	return dedupe(axes.map((raw) => assertLeafAxis(raw, label)));
+}
+/**
+* Input side: leaves, `custom:`, and compound diff axes, which expand to their leaves so
+* `changedAgentProfileAxes` output composes with a leaf-only contract.
+*/
+function normalizeChangedAxes(axes, label) {
+	const out = [];
+	for (const raw of axes) {
+		const axis = readAxisName(raw, label);
+		const leaves = compoundAxisLeaves[axis];
+		if (leaves && !KNOWN_AXIS_SET.has(axis)) {
+			out.push(...leaves);
+			continue;
+		}
+		out.push(assertLeafAxis(raw, label));
+	}
+	return dedupe(out);
+}
+function dedupe(axes) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const axis of axes) {
+		if (seen.has(axis)) continue;
+		seen.add(axis);
+		out.push(axis);
+	}
+	return out;
+}
+function readAxisName(raw, label) {
+	if (typeof raw !== "string") throw new ValidationError(`${label}: profile axis must be a string`);
+	const axis = raw.trim();
+	if (!axis) throw new ValidationError(`${label}: profile axis must be non-empty`);
+	return axis;
+}
+function assertLeafAxis(raw, label) {
+	const axis = readAxisName(raw, label);
+	if (!KNOWN_AXIS_SET.has(axis) && !axis.startsWith("custom:")) {
+		const leaves = compoundAxisLeaves[axis];
+		if (leaves) throw new ValidationError(`${label}: "${axis}" is a compound AgentProfile property, not a materialization axis. Name the exact leaves this path carries: ${leaves.join(", ")}.`);
+		throw new ValidationError(`${label}: unknown profile axis "${axis}". Use a known axis or custom:<name>.`);
+	}
+	return axis;
+}
+function isAxisSupported(axis, supported) {
+	return supported.has(axis);
+}
+//#endregion
 //#region src/mcp/worktree.ts
 /**
 *
@@ -1327,9 +1633,6 @@ async function removeWorktree(options) {
 * @experimental
 */
 const defaultCheckOutputCap = 16e3;
-function materializerHarness(harness) {
-	return harness === "claude" ? "claude-code" : harness;
-}
 /** This harness runs public plans only — it has no secret provider, so any
 *  templated argument or secret-ref env value is refused rather than leaked
 *  or silently stringified. */
@@ -1355,6 +1658,11 @@ async function runWorktreeHarness(opts) {
 	const runCommand = opts.runCommand ?? defaultRunCommand;
 	const checkTimeoutMs = opts.checkTimeoutMs ?? opts.harnessTimeoutMs ?? 300 * 1e3;
 	const cap = opts.checkOutputCap ?? defaultCheckOutputCap;
+	assertSupportedWorktreeProfile(opts.profile, opts.harness);
+	assertSafeProfileResourcePaths(opts.profile);
+	const profile = await resolveAgentProfileResources(opts.profile, resourceResolutionOptions(opts.resourceResolution, opts.signal));
+	opts.signal?.throwIfAborted();
+	const { plan, resourceInstructions } = prepareWorktreeProfile(profile, opts.harness);
 	const worktree = await createWorktree({
 		repoRoot: opts.repoRoot,
 		runId: opts.runId,
@@ -1367,19 +1675,11 @@ async function runWorktreeHarness(opts) {
 		...opts.runGit ? { runGit: opts.runGit } : {}
 	});
 	try {
-		assertSupportedWorktreeProfile(opts.profile, opts.harness);
-		assertSafeProfileResourcePaths(opts.profile);
-		const profile = await resolveAgentProfileResources(opts.profile, resourceResolutionOptions(opts.resourceResolution, opts.signal));
-		opts.signal?.throwIfAborted();
-		const resourceInstructions = resolveResourceInstructions(profile);
-		const plan = materializeProfile(materializationOnlyProfile(profile), materializerHarness(opts.harness));
-		if (plan.unsupported.length > 0) throw new Error(`runWorktreeHarness: profile cannot be materialized for ${opts.harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`);
-		assertSafeMaterializedPaths(plan);
 		const applied = applyWorkspacePlan(plan, worktree.path, { existingFiles: "reject" });
 		if (applied.unsupported.length > 0) throw new Error("runWorktreeHarness: applied profile unexpectedly retained unsupported rows");
 		const invocationProfile = profileWithResourceInstructions(profile, resourceInstructions);
 		const { command, args } = harnessInvocation(opts.harness, invocationProfile, opts.taskPrompt, {
-			dangerouslySkipPermissions: opts.harness === "claude",
+			dangerouslySkipPermissions: true,
 			...opts.codexReproducible ? { codexReproducible: true } : {}
 		});
 		const harnessResult = await runHarness({
@@ -1459,6 +1759,28 @@ async function runWorktreeHarness(opts) {
 		throw err;
 	}
 }
+/** Compute the same plan identity `runWorktreeHarness` consumes, with no repository or process IO. */
+function worktreeProfileExecutionPlan(profile, harness) {
+	const { plan, resourceInstructions } = prepareWorktreeProfile(profile, harness);
+	return Object.freeze({
+		workspacePlanDigest: hashWorkspacePlan(plan),
+		harness: plan.harness,
+		resourceInstructions: resourceInstructionReceipt(resourceInstructions)
+	});
+}
+function prepareWorktreeProfile(profile, harness) {
+	const resourceInstructions = resolveResourceInstructions(profile);
+	const workspaceProfile = materializationOnlyProfile(profile);
+	assertSupportedWorktreeProfile(profile, harness);
+	assertSafeProfileResourcePaths(profile);
+	const plan = materializeProfile(workspaceProfile, harness);
+	if (plan.unsupported.length > 0) throw new Error(`runWorktreeHarness: profile cannot be materialized for ${harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`);
+	assertSafeMaterializedPaths(plan);
+	return {
+		plan,
+		resourceInstructions
+	};
+}
 function resourceResolutionOptions(options, signal) {
 	if (!signal) return options;
 	const fetchResource = options?.fetch ?? globalThis.fetch;
@@ -1509,37 +1831,16 @@ function materializationOnlyProfile(profile) {
 	};
 }
 function assertSupportedWorktreeProfile(profile, harness) {
-	const unsupportedAxes = [
-		hasEntries(profile.tools) ? "tools" : null,
-		hasEntries(profile.permissions) ? "permissions" : null,
-		profile.connections && profile.connections.length > 0 ? "connections" : null,
-		hasEntries(profile.confidential) ? "confidential" : null,
-		hasEntries(profile.modes) ? "modes" : null,
-		hasEntries(profile.extensions) ? "extensions" : null
-	].filter((axis) => axis !== null);
-	if (profile.model?.reasoningEffort !== void 0 && harness !== "codex") unsupportedAxes.push("model.reasoningEffort");
-	for (const [name, server] of Object.entries(profile.mcp ?? {})) {
-		const path = `mcp[${JSON.stringify(name)}]`;
-		if (server.enabled === false && harness !== "opencode") unsupportedAxes.push(`${path}.enabled`);
-		if (hasEntries(server.headers) && harness === "codex") unsupportedAxes.push(`${path}.headers`);
-		if (server.cwd !== void 0 && harness === "opencode") unsupportedAxes.push(`${path}.cwd`);
-	}
-	if (harness === "claude") for (const [event, commands] of Object.entries(profile.hooks ?? {})) for (const [index, command] of commands.entries()) {
-		const path = `hooks[${JSON.stringify(event)}][${index}]`;
-		if (hasEntries(command.env)) unsupportedAxes.push(`${path}.env`);
-		if (command.blocking !== void 0) unsupportedAxes.push(`${path}.blocking`);
-	}
-	for (const [name, subagent] of Object.entries(profile.subagents ?? {})) {
-		const path = `subagents[${JSON.stringify(name)}]`;
-		if (hasEntries(subagent.permissions)) unsupportedAxes.push(`${path}.permissions`);
-		if (subagent.maxSteps !== void 0) unsupportedAxes.push(`${path}.maxSteps`);
-		if (hasEntries(subagent.tools) && harness !== "claude") unsupportedAxes.push(`${path}.tools`);
-	}
+	assertProfileMaterialization({
+		contract: worktreeCliProfileMaterialization,
+		changedAxes: profileMaterializationAxes(profile),
+		context: "runWorktreeHarness"
+	});
+	const unsupportedAxes = [];
+	const reasoningEffort = profile.model?.reasoningEffort;
+	if (reasoningEffort !== void 0 && !harnessSupportsReasoningEffort(harness, reasoningEffort)) unsupportedAxes.push("model.reasoningEffort");
 	if (unsupportedAxes.length > 0) throw new Error(`runWorktreeHarness: profile requests unsupported worktree behavior: ${unsupportedAxes.join(", ")}`);
 }
-function hasEntries(value) {
-	return value !== void 0 && Object.keys(value).length > 0;
-}
 function assertSafeMaterializedPaths(plan) {
 	for (const file of plan.files) if (file.relPath.split("/").some(isGitMetadataSegment)) throw new Error(`runWorktreeHarness: profile file cannot target reserved Git metadata: ${file.relPath}`);
 }
@@ -1551,22 +1852,26 @@ function isGitMetadataSegment(segment) {
 	return windowsCanonical === ".git" || windowsCanonical.startsWith(".git:");
 }
 function profileMaterializationReceipt(applied, resourceInstructions) {
-	const instructionBytes = resourceInstructions === void 0 ? null : Buffer.from(resourceInstructions, "utf8");
 	return {
 		workspacePlanDigest: applied.workspacePlanDigest,
 		writtenPaths: [...applied.written],
 		unsupported: [...applied.unsupported],
 		environmentNames: Object.keys(applied.env).sort(),
 		flags: applied.flags.map(publicPlanString),
-		resourceInstructions: instructionBytes ? {
-			delivery: "invocation-prompt",
-			sha256: `sha256:${createHash("sha256").update(instructionBytes).digest("hex")}`,
-			byteLength: instructionBytes.byteLength
-		} : {
-			delivery: "none",
-			sha256: null,
-			byteLength: 0
-		}
+		resourceInstructions: resourceInstructionReceipt(resourceInstructions)
+	};
+}
+function resourceInstructionReceipt(resourceInstructions) {
+	if (resourceInstructions === void 0) return {
+		delivery: "none",
+		sha256: null,
+		byteLength: 0
+	};
+	const instructionBytes = Buffer.from(resourceInstructions, "utf8");
+	return {
+		delivery: "invocation-prompt",
+		sha256: `sha256:${createHash("sha256").update(instructionBytes).digest("hex")}`,
+		byteLength: instructionBytes.byteLength
 	};
 }
 /** Run the configured test + typecheck commands in the live worktree, projecting exit codes into
@@ -1918,7 +2223,7 @@ function splitReasoning(rawContent, fieldReasoning) {
 */
 async function routerChatWithTools(cfg, messages, tools, opts) {
 	const body = toolCompletionBody(cfg, messages, tools, opts);
-	const data = cfg.complete ? await cfg.complete(body) : await (async () => {
+	const data = cfg.complete ? await cfg.complete(structuredClone(body)) : await (async () => {
 		const res = await fetch(`${cfg.routerBaseUrl.replace(/\/$/, "")}/chat/completions`, {
 			method: "POST",
 			headers: {
@@ -2209,240 +2514,1010 @@ function routerBrain(cfg, opts = {}) {
 	});
 }
 //#endregion
-//#region src/runtime/supervise/progress.ts
-/** How long a worker may produce no metered activity before a `progress()` read calls it stalled.
-*  Deliberately generous: a coding harness routinely spends minutes inside one tool call, and a
-*  false stall that provokes a steer is worse than a late one. */
-const DEFAULT_STALL_AFTER_MS = 18e4;
-/** Create a bounded activity ring. `limit` caps memory for a worker that runs thousands of tools. */
-function createActivityLog(limit = 12) {
-	const notes = [];
-	const cap = Math.max(1, Math.floor(limit));
-	return {
-		push(note) {
-			notes.push(note);
-			if (notes.length > cap) notes.splice(0, notes.length - cap);
-		},
-		read: () => [...notes],
-		last: () => notes[notes.length - 1],
-		size: () => notes.length
-	};
+//#region src/runtime/supervise/materialization.ts
+const runtimeOwnedExecutorMaterializations = /* @__PURE__ */ new WeakMap();
+const runtimeOwnedScopeOwners = /* @__PURE__ */ new WeakMap();
+const declarationKeys = /* @__PURE__ */ new Set([
+	"effectiveProfile",
+	"backend",
+	"model",
+	"execution",
+	"materializer",
+	"plan",
+	"platformAttachments"
+]);
+/**
+* Bind a declaration to a runtime-owned executor without putting an attestable method on the
+* public Executor interface. This module is not a package export: arbitrary caller executors stay
+* unknown even if they add a lookalike `materialization()` property.
+*/
+function attestRuntimeOwnedExecutor(executor, declaration, binding) {
+	runtimeOwnedExecutorMaterializations.set(executor, Object.freeze({
+		kind: "known",
+		declaration: detachedSnapshot(declaration, "runtime-owned executor materialization"),
+		...binding === void 0 ? {} : { binding: detachedSnapshot(binding, "runtime-owned executor execution binding") }
+	}));
+	return executor;
+}
+/** Mark a runtime-owned orchestration executor whose exact leaf declaration is published through
+* its private nested Scope before the first backend inference. Arbitrary executors cannot opt in. */
+function attestRuntimeOwnedDeferredExecutor(executor, runtime) {
+	runtimeOwnedExecutorMaterializations.set(executor, Object.freeze({
+		kind: "deferred",
+		runtime
+	}));
+	return executor;
+}
+/** Preserve the runtime-owned attestation when a trusted wrapper changes result semantics only. */
+function inheritRuntimeOwnedExecutorAttestation(source, wrapper) {
+	const attestation = runtimeOwnedExecutorMaterializations.get(source);
+	if (attestation !== void 0) runtimeOwnedExecutorMaterializations.set(wrapper, attestation);
+	return wrapper;
+}
+/** Read a declaration only when Runtime itself branded this exact executor object. */
+function runtimeOwnedExecutorMaterialization(executor) {
+	const attestation = runtimeOwnedExecutorMaterializations.get(executor);
+	return attestation?.kind === "known" ? attestation.declaration : void 0;
+}
+/** Read one attempt binding only from the private brand on this exact executor object. */
+function runtimeOwnedExecutorExecutionBinding(executor) {
+	const attestation = runtimeOwnedExecutorMaterializations.get(executor);
+	return attestation?.kind === "known" ? attestation.binding : void 0;
+}
+/** Read the expected leaf runtime only for a privately branded deferred orchestration executor. */
+function runtimeOwnedDeferredExecutorRuntime(executor) {
+	const attestation = runtimeOwnedExecutorMaterializations.get(executor);
+	return attestation?.kind === "deferred" ? attestation.runtime : void 0;
+}
+/** Propagate trust from a built-in driver adapter to the Agent and recursive executor it owns. */
+function attestRuntimeOwnedScopeOwner(owner, runtime) {
+	runtimeOwnedScopeOwners.set(owner, runtime);
+	return owner;
+}
+/** Return a built-in scope owner's expected concrete leaf runtime; caller-owned functions/Agents
+* deliberately have no entry even if they add lookalike fields. */
+function runtimeOwnedScopeOwnerRuntime(owner) {
+	return runtimeOwnedScopeOwners.get(owner);
+}
+/** Build one kernel-owned known receipt from a data-only executor declaration. */
+function knownMaterializationReceipt(input) {
+	const declaration = detachedSnapshot(input.declaration, "executor materialization");
+	assertExactDeclaration(declaration);
+	const effectiveProfile = agentProfileSchema.safeParse(declaration.effectiveProfile);
+	if (!effectiveProfile.success) throw new ValidationError("executor materialization: effectiveProfile must be an AgentProfile");
+	assertNonEmpty(declaration.backend, "backend");
+	assertNonEmpty(declaration.materializer, "materializer");
+	assertNonEmpty(declaration.execution?.kind, "execution.kind");
+	assertNonEmpty(declaration.execution?.id, "execution.id");
+	assertModel(declaration.model);
+	let effectiveProfileDigest;
+	let materializationPlanDigest;
+	let platformAttachmentsDigest;
+	try {
+		effectiveProfileDigest = canonicalCandidateDigest(jsonWireSnapshot(effectiveProfile.data));
+		materializationPlanDigest = canonicalCandidateDigest(jsonWireSnapshot(declaration.plan));
+		platformAttachmentsDigest = declaration.platformAttachments === void 0 ? void 0 : canonicalCandidateDigest(jsonWireSnapshot(declaration.platformAttachments));
+	} catch (error) {
+		throw new ValidationError("executor materialization: profile, plan, and attachments must be finite RFC 8785 JSON", { cause: error });
+	}
+	return Object.freeze({
+		status: "known",
+		authoredProfileDigest: input.authoredProfileDigest,
+		effectiveProfileDigest,
+		materializationPlanDigest,
+		...platformAttachmentsDigest === void 0 ? {} : { platformAttachmentsDigest },
+		runtime: input.runtime,
+		backend: declaration.backend,
+		model: declaration.model,
+		execution: declaration.execution,
+		materializer: declaration.materializer
+	});
 }
-/** Fold the scope-derived facts and the executor's optional enrichment into one read. Pure: the
-*  caller supplies `now`, so a test can observe a stall without waiting for one. */
-function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_AFTER_MS) {
-	const live = scope.status !== "done" && scope.status !== "failed" && scope.status !== "cancelled";
-	const executorActivityAt = executor?.recentActivity?.length ? executor.recentActivity[executor.recentActivity.length - 1].at : 0;
-	const lastActivityAt = Math.max(scope.lastActivityAt, executorActivityAt);
-	const idleMs = Math.max(0, now - lastActivityAt);
-	const note = executor?.note;
-	return {
-		id: scope.id,
-		status: scope.status,
-		live,
-		steerable: scope.steerable,
-		startedAt: scope.startedAt,
-		lastActivityAt,
-		idleMs,
-		stalled: live && idleMs > stallAfterMs,
-		stallAfterMs,
-		turns: executor?.turns ?? scope.turns,
-		tokens: scope.tokens,
-		...scope.tokensKnown === false ? { tokensKnown: false } : {},
-		usd: scope.usd,
-		...scope.usdKnown === false ? { usdKnown: false } : {},
-		pendingMessages: executor?.pendingMessages ?? 0,
-		recentActivity: executor?.recentActivity ?? [],
-		...executor?.derived?.length ? { derived: executor.derived } : {},
-		...note ? { note } : {}
-	};
+/** Build an explicit unknown receipt without fabricating any executor-owned identity. */
+function unknownMaterializationReceipt(input) {
+	return Object.freeze({
+		status: "unknown",
+		...input.authoredProfileDigest === void 0 ? {} : { authoredProfileDigest: input.authoredProfileDigest },
+		runtime: input.runtime,
+		reason: input.reason
+	});
+}
+/** Mint a process-unique attempt id before executor construction. */
+function newExecutionAttemptId(nodeId) {
+	return `${nodeId}:attempt:${randomUUID()}`;
+}
+/** Build the immutable safe receipt for a full, transient execution binding. */
+function knownExecutionBindingReceipt(materialization, bindingInput) {
+	const binding = detachedSnapshot(bindingInput, "executor execution binding");
+	assertNonEmpty(binding.attemptId, "binding.attemptId");
+	assertSafeDescriptor(binding.descriptor);
+	let materializationReceiptDigest;
+	let bindingDigest;
+	try {
+		materializationReceiptDigest = canonicalCandidateDigest(materialization);
+		bindingDigest = canonicalCandidateDigest(jsonWireSnapshot(binding.binding));
+	} catch (error) {
+		throw new ValidationError("executor binding must be finite RFC 8785 JSON", { cause: error });
+	}
+	return Object.freeze({
+		status: "known",
+		attemptId: binding.attemptId,
+		materializationReceiptDigest,
+		bindingDigest,
+		descriptor: binding.descriptor
+	});
+}
+/** Preserve an attempt boundary even when its caller-owned transport cannot be attested. */
+function unknownExecutionBindingReceipt(materialization, attemptId, reason) {
+	assertNonEmpty(attemptId, "binding.attemptId");
+	return Object.freeze({
+		status: "unknown",
+		attemptId,
+		materializationReceiptDigest: canonicalCandidateDigest(materialization),
+		reason
+	});
+}
+/** Derive an authored-profile digest without turning non-canonical input into a fake identity. */
+function authoredProfileDigest(profile) {
+	try {
+		return canonicalCandidateDigest(profile);
+	} catch {
+		return;
+	}
+}
+function assertExactDeclaration(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError("executor materialization: declaration must be an object");
+	const unknown = Object.keys(value).filter((key) => !declarationKeys.has(key));
+	if (unknown.length > 0) throw new ValidationError(`executor materialization: unknown declaration fields: ${unknown.sort().join(", ")}`);
+	if (!Object.hasOwn(value, "plan")) throw new ValidationError("executor materialization: plan is required");
+}
+function assertModel(model) {
+	if (typeof model !== "object" || model === null || Array.isArray(model)) throw new ValidationError("executor materialization: model must be a known/unknown identity");
+	const keys = Object.keys(model).sort();
+	if (model.status === "known") {
+		if (keys.join(",") !== "id,status") throw new ValidationError("executor materialization: known model accepts only status and id");
+		assertNonEmpty(model.id, "model.id");
+		return;
+	}
+	if (model.status === "unknown") {
+		if (keys.join(",") !== "reason,status") throw new ValidationError("executor materialization: unknown model accepts only status and reason");
+		assertNonEmpty(model.reason, "model.reason");
+		return;
+	}
+	throw new ValidationError("executor materialization: model.status must be known or unknown");
+}
+function assertNonEmpty(value, field) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new ValidationError(`executor materialization: ${field} must be a non-empty string`);
+}
+function assertSafeDescriptor(descriptor) {
+	if (typeof descriptor !== "object" || descriptor === null || Array.isArray(descriptor)) throw new ValidationError("executor binding: descriptor must be an object");
+	for (const [key, value] of Object.entries(descriptor)) {
+		if (/(url|uri|token|key|secret|bearer|credential|authorization)/i.test(key)) throw new ValidationError(`executor binding: unsafe descriptor key ${JSON.stringify(key)}`);
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new ValidationError(`executor binding: descriptor ${JSON.stringify(key)} must be scalar`);
+		if (typeof value === "string" && (value.includes("://") || value.includes("@"))) throw new ValidationError(`executor binding: descriptor ${JSON.stringify(key)} contains transport or credential text`);
+	}
+}
+function jsonWireSnapshot(value, path = "$") {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new ValidationError(`executor binding: ${path} must be finite`);
+		return value;
+	}
+	if (Array.isArray(value)) return value.map((item, index) => {
+		if (item === void 0) throw new ValidationError(`executor binding: ${path}[${index}] cannot be undefined`);
+		return jsonWireSnapshot(item, `${path}[${index}]`);
+	});
+	if (typeof value !== "object" || value === null) throw new ValidationError(`executor binding: ${path} must be JSON data`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new ValidationError(`executor binding: ${path} must be a plain object`);
+	const out = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (item === void 0) continue;
+		out[key] = jsonWireSnapshot(item, `${path}.${key}`);
+	}
+	return out;
 }
 //#endregion
-//#region src/runtime/supervise/wait.ts
+//#region src/runtime/supervise/budget.ts
 /**
 *
-* WAIT-STATES — a supervision-tree node that waits on wall-clock time or an external condition
-* without holding a worker, an executor, a sandbox, or a single LLM turn.
-*
-* A long-horizon run spends most of its wall-clock NOT computing: waiting for CI to finish,
-* for a nightly job to land, for a human to reply, for a rate-limit window to reopen. Before
-* this, the only way to express that was to keep something alive and re-ask — which spends
-* driver tokens per re-ask and pins a process to the wait.
-*
-* Two node kinds, both first-class:
-*   - `timer` — wake at an ABSOLUTE wall-clock instant (`untilMs`).
-*   - `poll`  — re-run a named predicate every `intervalMs` until it returns true, or until an
-*               absolute `timeoutAtMs` passes (CI status, file existence, an HTTP probe, an
-*               inbox message).
-*
-* ── How this differs from `await_event`'s 15s poll fence (`DEFAULT_AWAIT_EVENT_TIMEOUT_MS`) ──
-*
-* They look similar and are not the same mechanism. `await_event` is an IN-RUN RENDEZVOUS: the
-* driver blocks on the coordination bus for the next event from a live worker, and the 15s fence
-* exists only so a remote MCP request does not exceed the client's timeout — the caller re-polls.
-* Every re-poll is another driver inference turn (real tokens) against a process that must stay
-* up, and nothing about that wait is recorded: kill the process and the wait is simply gone.
+* The conserved budget reservation pool — the invariant the whole instrument
+* rests on (critique M5/B3). One root `Budget` becomes a conserved pool of three
+* quantities (tokens, usd, iterations) plus an absolute deadline. Children reserve
+* atomically at spawn and reconcile at settle:
 *
-* A wait-state is a NODE, not a call. It has a node id in the tree, a journal record carrying its
-* ABSOLUTE deadline, and it settles through the same `Scope.next()` cursor as any worker. Nobody
-* is blocked on it — the driver can stop reasoning entirely, and the process can die. Cost while
-* waiting: zero LLM calls, zero executor, zero sandbox, zero conserved budget (a wait reserves
-* nothing from the pool). The only in-process residue is one timer entry.
+*   total ≡ free + reserved + committed          (for every known quantity)
 *
-* ── Why probes are NAMED, not passed as closures ────────────────────────────────────────────
+* `reserve` moves a child's whole ceiling from `free` → `reserved` and fails closed
+* when `free` can't cover it (never read-then-spawn overcommit, so `Σk(treatment) ≡
+* Σk(blind)` by construction). `reconcile` releases the reservation, commits ACTUAL
+* spend, and refunds the unspent remainder to `free`. Tokens and usd are separate
+* channels (`LoopTokenUsage` has no `usd`); iterations are conserved alongside them.
 *
-* A wait must survive a process restart with its original deadline intact, and a closure cannot
-* be journaled. So a `poll` names its predicate (`probe: 'ci-green'`) and the run resolves it
-* through a `WaitProbeRegistry`. A brand-new process re-resolves the SAME name against its own
-* registry and re-arms the wait — which is what makes "kill the box, the wait keeps waiting"
-* true rather than aspirational.
+* Pure and deterministic: `now()` is injected, there is no I/O, and no wall-clock or
+* RNG read. A `reserve`/`reconcile` ticket is single-use (fail-loud on double or
+* unknown reconcile) so a child can never refund twice. Reconciling an OPEN ticket always
+* closes it: a fail-loud condition settles the reservation first and throws afterwards, so no
+* error path can strand a reservation past the join barrier's `assertNoOpenTickets`.
+* A child that declared no `maxUsd` reserved no dollar allocation, so its real dollars are
+* committed as observed spend and debited from the root's balance rather than treated as an
+* overspend of a $0 ceiling it never asked for. If dollar cost is unknowable under a
+* dollar limit, reconciliation closes the known token/iteration work, marks the dollar channel
+* unusable, and refuses later reservations; inventing a numeric dollar total would be worse.
+* If a TOKEN count is unknowable (a provider that reported no usage for work that ran), the pool
+* records the work, debits what it knows, and marks `readout().tokensKnown` false — the balance is
+* then a ceiling, not a measurement. It does not close admission the way the dollar channel does:
+* tokens are always capped, so one unreported turn must not end the run.
 *
-* Absolute instants for the same reason: `untilMs` / `timeoutAtMs` are epoch ms, not durations,
-* so a resumed wait counts down from the original arm, not from the restart. `timerAt`/`pollFor`
-* build them from a duration when that is what the caller has.
+* A pool can be RESTORED from a prior process's durable record (same-host restart): measured
+* committed spend is debited exactly once, and each child journaled as started but never settled
+* is charged at its full declared ceiling — restart never mints capacity, and the unknown flags
+* stay visible in every later readout. The original absolute deadline never slides.
 *
 * @experimental
 */
-/** Build a `timer` spec from a DURATION. The instant is resolved once, at arm time — a resumed
-*  wait re-uses the journaled instant, never a fresh `now + ms`. */
-function timerAt(ms, now) {
-	return {
-		kind: "timer",
-		untilMs: now + ms
+/** Reject malformed ceilings before they can mint capacity through negative reservations. */
+function assertValidBudget(budget, label = "budget") {
+	const safeInteger = (value, field) => {
+		if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label}.${field} must be a non-negative safe integer`);
+	};
+	const finiteNonNegative = (value, field) => {
+		if (!Number.isFinite(value) || value < 0) throw new Error(`${label}.${field} must be a non-negative finite number`);
 	};
+	safeInteger(budget.maxIterations, "maxIterations");
+	safeInteger(budget.maxTokens, "maxTokens");
+	if (budget.maxUsd !== void 0) finiteNonNegative(budget.maxUsd, "maxUsd");
+	if (budget.deadlineMs !== void 0) finiteNonNegative(budget.deadlineMs, "deadlineMs");
 }
-/** Build a bounded `poll` spec from a duration. */
-function pollFor(probe, opts, now) {
+function assertValidSpend(spend, label) {
+	if (!Number.isSafeInteger(spend.iterations) || spend.iterations < 0) throw new Error(`${label}.iterations must be a non-negative safe integer`);
+	for (const [field, value] of Object.entries(spend.tokens)) if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${label}.tokens.${field} must be a non-negative safe integer`);
+	for (const [field, value] of [["usd", spend.usd], ["ms", spend.ms]]) if (!Number.isFinite(value) || value < 0) throw new Error(`${label}.${field} must be a non-negative finite number`);
+}
+/** Fold a normalized `UsageEvent` array into a `Spend`. Tokens and usd are separate
+*  channels; iterations come from `'iteration'` events. Pure; `ms` stays zero (the
+*  pool does not read wall-clock). */
+function spendFromUsageEvents(events) {
+	const tokens = zeroTokenUsage();
+	let usd = 0;
+	let usdKnown = true;
+	let iterations = 0;
+	for (const ev of events) if (ev.kind === "tokens") addTokenUsage(tokens, {
+		input: ev.input,
+		output: ev.output
+	});
+	else if (ev.kind === "cost") {
+		usd += ev.usd;
+		if (ev.usdKnown === false) usdKnown = false;
+	} else iterations += 1;
 	return {
-		kind: "poll",
-		probe,
-		intervalMs: opts.intervalMs,
-		...opts.timeoutMs !== void 0 ? { timeoutAtMs: now + opts.timeoutMs } : {},
-		...opts.args ? { args: opts.args } : {}
+		iterations,
+		tokens,
+		usd,
+		...usdKnown ? {} : { usdKnown: false },
+		ms: 0
 	};
 }
-/** Registry over a plain name→predicate record. */
-function createWaitProbes(entries) {
-	const map = new Map(Object.entries(entries));
-	return { resolve: (name) => map.get(name) };
-}
-/** Narrow a settlement's `out` to a wait outcome — a wait settles on the SAME cursor as workers,
-*  so a driver that mixes them tags them apart with this. */
-function isWaitOutcome(value) {
-	return typeof value === "object" && value !== null && value.waitOutcome === true;
-}
-/** The absolute instant a spec is bounded by, or `undefined` for an unbounded poll. */
-function waitUntil(spec) {
-	return spec.kind === "timer" ? spec.untilMs : spec.timeoutAtMs;
-}
-/** Structural validation, independent of the run. Returns null when the spec is usable. */
-function validateWaitSpec(spec) {
-	if (spec.kind === "timer") return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
-	if (typeof spec.probe !== "string" || spec.probe.length === 0) return "poll.probe must be a non-empty probe name";
-	if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) return "poll.intervalMs must be > 0";
-	if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) return "poll.timeoutAtMs must be a finite epoch-ms instant";
-	return null;
+async function foldUsage(events) {
+	if (Array.isArray(events)) return spendFromUsageEvents(events);
+	const tokens = zeroTokenUsage();
+	let usd = 0;
+	let usdKnown = true;
+	let iterations = 0;
+	for await (const ev of events) if (ev.kind === "tokens") addTokenUsage(tokens, {
+		input: ev.input,
+		output: ev.output
+	});
+	else if (ev.kind === "cost") {
+		usd += ev.usd;
+		if (ev.usdKnown === false) usdKnown = false;
+	} else iterations += 1;
+	return {
+		iterations,
+		tokens,
+		usd,
+		...usdKnown ? {} : { usdKnown: false },
+		ms: 0
+	};
 }
-/**
-* A wait must not silently outlive the run's HARD wall-clock ceiling. When the conserved pool
-* carries an absolute `deadlineMs`, a wait bounded past it — or an unbounded poll — is REFUSED at
-* arm time (`deadline-exceeded`) rather than sleeping through a ceiling the caller already set.
-* The alternative (extending the pool's deadline to cover the wait) would let a wait override a
-* hard budget guard, which is exactly what mechanic D forbids; a run that intends week-long waits
-* either sets a deadline that covers them or sets none.
-*/
-function assertWaitWithinDeadline(spec, deadlineMs) {
-	if (deadlineMs <= 0) return true;
-	const until = waitUntil(spec);
-	if (until === void 0) return false;
-	return until <= deadlineMs;
+function totalTokens(usage) {
+	return usage.input + usage.output;
 }
 /**
-* Drive one wait to its resolution. Spends nothing: a `timer` is one sleep, a `poll` is a sleep
-* between predicate checks. No LLM call, no executor, no box, no budget reservation.
+* Create a conserved reservation pool from a root `Budget`. `now()` is injected so the
+* deadline readout is deterministic; defaults to `Date.now` for non-test callers. The
+* absolute deadline for a fresh pool is fixed at construction (`now() + budget.deadlineMs`). A
+* restored pool instead retains `restore.absoluteDeadlineMs`, so restart never slides the original
+* wall-clock limit. The readout is an absolute instant, not a shrinking remainder.
 */
-async function runWait(args) {
-	const { spec, label, armedAt, resumed, signal, now } = args;
-	const sleep = args.sleep ?? defaultSleep;
-	if (signal.aborted) return {
-		kind: "cancelled",
-		reason: "aborted before arming"
-	};
-	if (spec.kind === "timer") {
-		const remaining = spec.untilMs - now();
-		if (remaining > 0) await sleep(remaining, signal);
-		if (signal.aborted) return {
-			kind: "cancelled",
-			reason: "wait aborted"
+function createBudgetPool(root, now = Date.now, restore = {}) {
+	assertValidBudget(root, "root budget");
+	if (restore.absoluteDeadlineMs !== void 0 && (!Number.isFinite(restore.absoluteDeadlineMs) || restore.absoluteDeadlineMs < 0)) throw new Error("budget restore.absoluteDeadlineMs must be a non-negative finite number");
+	let freeTokens = root.maxTokens;
+	let reservedTokens = 0;
+	let committedTokens = 0;
+	let tokensTainted = false;
+	const usdCapped = root.maxUsd !== void 0;
+	let freeUsd = root.maxUsd ?? 0;
+	let reservedUsd = 0;
+	let committedUsd = 0;
+	let usdTainted = false;
+	let usdMeasured = true;
+	let freeIterations = root.maxIterations;
+	let reservedIterations = 0;
+	let committedIterations = 0;
+	const absoluteDeadlineMs = restore.absoluteDeadlineMs ?? (root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0);
+	let nextTicketId = 0;
+	const open = /* @__PURE__ */ new Set();
+	function reserve(b) {
+		assertValidBudget(b, "reservation budget");
+		const wantTokens = b.maxTokens;
+		const wantUsd = b.maxUsd ?? 0;
+		const wantIterations = b.maxIterations;
+		if (usdCapped && usdTainted) return {
+			ok: false,
+			reason: "budget-exhausted"
 		};
-		return {
-			kind: "woke",
-			outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
+		if (wantTokens > freeTokens) return {
+			ok: false,
+			reason: "budget-exhausted"
 		};
-	}
-	const probe = args.probes?.resolve(spec.probe);
-	if (!probe) throw new ValidationError(`wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`);
-	let polls = 0;
-	let probeErrors = 0;
-	for (;;) {
-		if (signal.aborted) return {
-			kind: "cancelled",
-			reason: "wait aborted"
+		if (wantIterations > freeIterations) return {
+			ok: false,
+			reason: "budget-exhausted"
 		};
-		polls += 1;
-		let fired = false;
-		try {
-			fired = await probe(spec.args, signal);
-		} catch {
-			probeErrors += 1;
+		if (wantUsd > 0 && !usdCapped) return {
+			ok: false,
+			reason: "usd-unbudgeted"
+		};
+		if (wantUsd > freeUsd) return {
+			ok: false,
+			reason: "budget-exhausted"
+		};
+		freeTokens -= wantTokens;
+		reservedTokens += wantTokens;
+		freeIterations -= wantIterations;
+		reservedIterations += wantIterations;
+		if (wantUsd > 0) {
+			freeUsd -= wantUsd;
+			reservedUsd += wantUsd;
 		}
-		if (fired) return {
-			kind: "woke",
-			outcome: outcome("poll", "fired", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
+		const id = nextTicketId++;
+		open.add(id);
+		return {
+			ok: true,
+			ticket: {
+				id,
+				reserved: {
+					tokens: wantTokens,
+					usd: wantUsd,
+					iterations: wantIterations,
+					usdBudgeted: b.maxUsd !== void 0
+				}
+			}
 		};
-		if (spec.timeoutAtMs !== void 0 && now() >= spec.timeoutAtMs) return {
-			kind: "woke",
-			outcome: outcome("poll", "timeout", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
+	}
+	function reconcile(ticket, spent) {
+		if (!open.has(ticket.id)) throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`);
+		assertValidSpend(spent, `budget pool ticket ${ticket.id} spend`);
+		const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved;
+		const unknownUnderCap = usdCapped && spent.usdKnown === false;
+		const spentTokens = totalTokens(spent.tokens);
+		const usdBudgeted = ticket.reserved.usdBudgeted !== false;
+		let violation;
+		if (spentTokens > rTokens) violation = `ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`;
+		else if (spent.iterations > rIterations) violation = `ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`;
+		else if (usdCapped && usdBudgeted && spent.usd > rUsd) violation = `ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`;
+		else if (unknownUnderCap) violation = `ticket ${ticket.id} reported unknown dollar cost under a dollar-capped budget`;
+		open.delete(ticket.id);
+		if (spent.tokensKnown === false) tokensTainted = true;
+		if (spent.usdKnown === false) usdMeasured = false;
+		reservedTokens -= rTokens;
+		committedTokens += spentTokens;
+		freeTokens += rTokens - spentTokens;
+		reservedIterations -= rIterations;
+		committedIterations += spent.iterations;
+		freeIterations += rIterations - spent.iterations;
+		if (usdCapped) {
+			reservedUsd -= rUsd;
+			committedUsd += spent.usd;
+			if (unknownUnderCap) {
+				usdTainted = true;
+				freeUsd = 0;
+			} else freeUsd += rUsd - spent.usd;
+		} else committedUsd += spent.usd;
+		if (violation !== void 0) throw new Error(`budget pool: ${violation}`);
+	}
+	function observe(spend) {
+		assertValidSpend(spend, "observed spend");
+		if (usdCapped && spend.usdKnown === false) throw new Error("budget pool: cannot observe unknown dollar cost under a dollar-capped budget");
+		if (spend.tokensKnown === false) tokensTainted = true;
+		if (spend.usdKnown === false) usdMeasured = false;
+		const tokens = totalTokens(spend.tokens);
+		freeTokens -= tokens;
+		committedTokens += tokens;
+		freeIterations -= spend.iterations;
+		committedIterations += spend.iterations;
+		committedUsd += spend.usd;
+		if (usdCapped) freeUsd -= spend.usd;
+	}
+	function readout() {
+		return {
+			tokensLeft: freeTokens,
+			tokensKnown: !tokensTainted,
+			usdLeft: usdCapped ? usdTainted ? 0 : freeUsd : 0,
+			usdCapped,
+			usdKnown: usdMeasured && !usdTainted,
+			iterationsLeft: freeIterations,
+			deadlineMs: absoluteDeadlineMs,
+			reservedTokens
 		};
-		await sleep(spec.timeoutAtMs === void 0 ? spec.intervalMs : Math.min(spec.intervalMs, Math.max(0, spec.timeoutAtMs - now())), signal);
 	}
-}
-function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeErrors, resumed) {
+	function assertNoOpenTickets() {
+		if (open.size > 0) throw new Error(`budget pool: ${open.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open].join(", ")}) — conserved-pool invariant violated`);
+	}
+	if (restore.committed !== void 0) {
+		assertValidSpend(restore.committed, "budget restore committed");
+		const committed = restore.committed;
+		if (committed.tokensKnown === false) tokensTainted = true;
+		if (committed.usdKnown === false) usdMeasured = false;
+		const tokens = totalTokens(committed.tokens);
+		freeTokens -= tokens;
+		committedTokens += tokens;
+		freeIterations -= committed.iterations;
+		committedIterations += committed.iterations;
+		committedUsd += committed.usd;
+		if (usdCapped) {
+			freeUsd -= committed.usd;
+			if (committed.usdKnown === false) {
+				usdTainted = true;
+				if (freeUsd > 0) committedUsd += freeUsd;
+				freeUsd = 0;
+			}
+		}
+	}
+	for (const [index, uncertain] of (restore.uncertainReservations ?? []).entries()) {
+		assertValidBudget(uncertain, `budget restore uncertainReservations[${index}]`);
+		tokensTainted = true;
+		usdMeasured = false;
+		freeTokens -= uncertain.maxTokens;
+		committedTokens += uncertain.maxTokens;
+		freeIterations -= uncertain.maxIterations;
+		committedIterations += uncertain.maxIterations;
+		if (usdCapped) if (uncertain.maxUsd === void 0) {
+			usdTainted = true;
+			committedUsd += freeUsd > 0 ? freeUsd : 0;
+			freeUsd = 0;
+		} else {
+			freeUsd -= uncertain.maxUsd;
+			committedUsd += uncertain.maxUsd;
+		}
+	}
 	return {
-		waitOutcome: true,
-		kind,
-		settled,
-		label,
-		...untilMs !== void 0 ? { untilMs } : {},
-		armedAt,
-		wokenAt,
-		polls,
-		probeErrors,
-		resumed
+		reserve,
+		reconcile,
+		spendFrom: foldUsage,
+		readout,
+		observe,
+		assertNoOpenTickets
 	};
 }
-/** `setTimeout` that resolves early (and clears) when the scope aborts, so a cancelled wait
-*  releases the event loop immediately instead of holding the process to its deadline. */
-function defaultSleep(ms, signal) {
-	if (ms <= 0 || signal.aborted) return Promise.resolve();
-	return new Promise((resolve) => {
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		function onAbort() {
-			clearTimeout(timer);
-			resolve();
-		}
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
+//#endregion
+//#region src/runtime/supervise/budget-floor.ts
+const WORKER_TOKEN_FLOOR = {
+	pi: 31211,
+	opencode: null,
+	"claude-code": null,
+	"kimi-code": null,
+	codex: null,
+	amp: null,
+	"factory-droids": null,
+	hermes: null,
+	forge: null,
+	openclaw: null,
+	nanoclaw: null,
+	acp: null,
+	cursor: null,
+	"cli-base": null
+};
+/**
+* The floor for a spawn's harness, or `null` when there is none to enforce.
+*
+* A `null` harness is the router/inline arm: it holds only coordination verbs and re-sends no
+* harness scaffolding, so it has no floor of this kind.
+*
+* Accepts a bare `string` because `AgentProfile.harness` is not exactly `BackendType` — an
+* unrecognised name resolves to `null` (no floor) rather than throwing, which keeps an unknown
+* harness admissible instead of refusing work on a name this table has not heard of.
+*/
+function workerTokenFloor(harness) {
+	if (harness === null || harness === void 0) return null;
+	return WORKER_TOKEN_FLOOR[harness] ?? null;
 }
 //#endregion
-//#region src/sanitize.ts
-/** Strip PII and large blobs from a `KnowledgeReadinessReport` for safe telemetry emission. @stable */
-function sanitizeKnowledgeReadinessReport(report, options = {}) {
-	return {
-		taskId: report.taskId,
+//#region src/runtime/supervise/deadline.ts
+const MAX_TIMER_DELAY_MS = 2147483647;
+const DEFAULT_SUCCESSFUL_SHUTDOWN_MS = 5e3;
+const TEARDOWN_ACKNOWLEDGEMENT_MS = 250;
+/** Arm one wall-clock deadline without keeping the Node.js process alive. */
+function armDeadlineTimer(delayMs, onDeadline) {
+	const deadlineAtMs = Date.now() + Math.max(0, delayMs);
+	let cleared = false;
+	let timer;
+	const arm = () => {
+		if (cleared) return;
+		const remainingMs = Math.max(0, deadlineAtMs - Date.now());
+		timer = setTimeout(() => {
+			if (cleared) return;
+			if (Date.now() >= deadlineAtMs) onDeadline();
+			else arm();
+		}, Math.min(remainingMs, MAX_TIMER_DELAY_MS));
+		if (typeof timer.unref === "function") timer.unref();
+	};
+	arm();
+	return () => {
+		cleared = true;
+		if (timer !== void 0) clearTimeout(timer);
+	};
+}
+/**
+* Resolve a spawned child's duration into one absolute cutoff. An omitted child deadline inherits
+* the parent cutoff; an explicit child duration may shorten, but never extend, that cutoff.
+*/
+function boundedChildDeadlineAt(parentDeadlineAtMs, childDeadlineMs, nowMs) {
+	const parent = parentDeadlineAtMs > 0 ? parentDeadlineAtMs : void 0;
+	const child = childDeadlineMs === void 0 ? void 0 : nowMs + childDeadlineMs;
+	if (parent === void 0) return child;
+	if (child === void 0) return parent;
+	return Math.min(parent, child);
+}
+/** Invoke teardown once and bound how long the runtime waits for its acknowledgement. A hard
+* execution deadline always wins; without one, numeric grace gets a short acknowledgement
+* allowance and a brutal kill gets only that allowance. Explicit `infinity` remains unbounded
+* only when no execution deadline exists. The losing promise stays observed. */
+async function teardownExecutor(executor, grace, deadlineAtMs, now) {
+	const work = Promise.resolve(executor.teardown(grace));
+	const requestedWaitMs = grace === "infinity" ? void 0 : grace === "brutalKill" ? TEARDOWN_ACKNOWLEDGEMENT_MS : grace + TEARDOWN_ACKNOWLEDGEMENT_MS;
+	const deadlineWaitMs = deadlineAtMs === void 0 ? void 0 : Math.max(0, deadlineAtMs - now()) + TEARDOWN_ACKNOWLEDGEMENT_MS;
+	const waitMs = requestedWaitMs === void 0 ? deadlineWaitMs : deadlineWaitMs === void 0 ? requestedWaitMs : Math.min(requestedWaitMs, deadlineWaitMs);
+	let receipt;
+	if (waitMs === void 0) receipt = await work;
+	else if (waitMs <= 0) {
+		work.catch(() => void 0);
+		throw new ValidationError("executor teardown did not acknowledge before its deadline");
+	} else {
+		let timer;
+		const timedOut = new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new ValidationError(`executor teardown did not acknowledge within ${waitMs}ms`)), waitMs);
+		});
+		try {
+			receipt = await Promise.race([work, timedOut]);
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	}
+	if (!receipt.destroyed) throw new ValidationError("executor teardown reported destroyed=false");
+}
+//#endregion
+//#region src/runtime/supervise/dispatch.ts
+/**
+*
+* `rollingDispatch` — the REFILLING dispatch policy over a `Scope`. It keeps `width` children in
+* flight and admits the next queued unit of work the instant one settles, instead of waiting for
+* a whole round to drain (`fanout`) or for a driver to decide again (`spawn → await → spawn`).
+*
+* The gap it closes: `fanout` opens every item at once and then drains — one round, no refill —
+* and a driver brain's manual loop opens one worker per model turn. Between those two there was
+* nothing that holds N slots full, which is why a 5-worker run can peak at 2 live workers and sit
+* ~50% idle. This is a policy over the EXISTING `Scope.spawn` / `Scope.next` primitives: it adds
+* no second admission path, so the conserved budget pool stays the only fence on total work and
+* `width` is only a fence on simultaneous work.
+*
+* Fail-closed by construction: an admission rejection (`budget-exhausted` / `depth-exceeded`) is
+* recorded and STOPS further admission — the loop then drains what is already live and returns.
+* It never retries a rejected spawn against the same pool, and it never spawns past `width`.
+*
+* ── The concurrency-cap ledger (read this before adding a fourth cap) ──────────────────────────
+*
+* Three unrelated caps bound "how much runs at once" in this stack, at three different layers.
+* They are NOT aware of each other, and the smallest one silently wins:
+*
+*   1. `SuperviseOptions.maxLiveWorkers` (`src/runtime/supervise/supervise.ts`) — supervised-tree
+*      level. One shared Scope counter bounds every spawned manager and leaf in the recursive tree;
+*      `spawn_agent` fails closed with `error: 'max-live-workers'` past it. Unset ⇒ NO tree cap.
+*      `CoordinationToolsOptions.maxLiveWorkers` remains the local form for a toolbox mounted on a
+*      caller-owned Scope that has no tree limit.
+*   2. `SandboxLineage`'s `maxConcurrency` / `DEFAULT_FORK_CONCURRENCY = 4`
+*      (`src/runtime/sandbox-lineage.ts`) — kernel level. How many BOXES one `runAgentRounds` fork wave
+*      provisions at once. It bounds a single leaf's fanout, not the supervisor's worker count.
+*   3. A host's own live-box governor (e.g. the kernel's `ComputeGovernor`, `maxSandboxes = 4`) — fleet
+*      level. How many sandboxes may exist across the whole host process.
+*
+* The honest effective limit on simultaneous WORKERS is the minimum of the caps that apply to the
+* worker layer — (1) and (3). (2) is a different unit (boxes per fork wave inside one leaf) and
+* must not be min'd into it, or a 4-way fork inside one worker reads as a 4-worker ceiling.
+* `effectiveConcurrency` computes that minimum in one place so a host derives ONE number and
+* passes it to BOTH `maxLiveWorkers` and this dispatcher's `width`, instead of leaving a fleet
+* governor of 4 and an unset worker fence as unrelated numbers.
+*
+* ── Why this is not a copy of the kernel's batch loop ──────────────────────────────────────────
+*
+* `runBatch` (`src/runtime/run-loop.ts`) runs the same hold-N-slots-full shape over the KERNEL's
+* substrate: bare promises in a `Set`, raced with `Promise.race`, bounded by `maxConcurrency`.
+* This one runs it over the SUPERVISOR's substrate — `Scope.spawn`'s atomic reservation against
+* the conserved pool, `Scope.next`'s journaled settlement cursor, and the blob store behind each
+* result. Neither can be expressed in the other's terms without dragging its whole substrate
+* along: the kernel loop has no budget to reserve and no cursor to order settlements by, and this
+* one cannot race raw promises because a settlement is only real once it is journaled. The shape
+* repeating across the two deliberate layers is resonance, not duplication — do not "unify" them
+* into a shared helper that would have to know about both.
+*
+* @experimental
+*/
+/**
+* Run the refilling dispatch loop over `scope` until the queue is dry (or a stop fires) and every
+* admitted child has settled. Returns the settlements in cursor order plus the admission ledger.
+*
+* The loop is: fill free slots from `nextUnit` → `await scope.next()` → deliver the settlement →
+* refill → repeat. Because the refill happens immediately after each settlement rather than after
+* a whole round, a slow child never idles the other slots.
+*/
+async function rollingDispatch(scope, opts) {
+	if (!Number.isInteger(opts.width) || opts.width < 1) throw new ValidationError(`rollingDispatch: width must be a positive integer, got ${String(opts.width)}`);
+	const settled = [];
+	const rejected = [];
+	const live = /* @__PURE__ */ new Set();
+	let admitted = 0;
+	let peakLive = 0;
+	let queueDry = false;
+	let stopReason = "drained";
+	const fill = async () => {
+		while (live.size < opts.width) {
+			if (queueDry) return;
+			if (scope.signal.aborted) {
+				stopReason = "aborted";
+				queueDry = true;
+				return;
+			}
+			if (opts.shouldStop?.() === true) {
+				stopReason = "stopped";
+				queueDry = true;
+				return;
+			}
+			const unit = await opts.nextUnit();
+			if (unit === void 0) {
+				queueDry = true;
+				return;
+			}
+			const res = scope.spawn(unit.agent, unit.task, unit.opts);
+			if (!res.ok) {
+				rejected.push(`${unit.opts.label}: ${res.reason}`);
+				stopReason = "not-admitted";
+				queueDry = true;
+				return;
+			}
+			live.add(res.handle.id);
+			admitted += 1;
+			if (live.size > peakLive) peakLive = live.size;
+		}
+	};
+	await fill();
+	while (live.size > 0) {
+		const s = await scope.next();
+		if (s === null) break;
+		live.delete(s.handle.id);
+		settled.push(s);
+		await opts.onSettled?.(s);
+		await fill();
+	}
+	return {
+		settled,
+		admitted,
+		rejected,
+		stopReason,
+		peakLive
+	};
+}
+/**
+* Free worker slots under a simultaneity cap: `cap - live`, floored at 0, or `null` when there is
+* no cap (the conserved pool is then the only fence and "free slots" is not a finite number).
+* The one place the answer is computed, so the driver-facing tool payload and a dispatcher agree.
+*/
+function freeSlots(liveCount, cap) {
+	if (cap === void 0 || cap <= 0) return null;
+	return Math.max(0, cap - liveCount);
+}
+/**
+* The ONE honest effective limit on simultaneous workers: the minimum of the caps that actually
+* bound the worker layer. Ignores unset/non-positive caps; returns `undefined` when no cap applies
+* (uncapped — the conserved pool remains the only fence).
+*
+* Deliberately does NOT fold in `SandboxLineage`'s fork concurrency: that bounds boxes inside ONE
+* leaf's fork wave, a different unit. Folding it in would report a 4-worker ceiling for what is
+* really a 4-box fanout inside a single worker.
+*
+* Use it once, at the top of a run, and pass the result to BOTH `maxLiveWorkers` and a
+* dispatcher's `width` — that is what turns three unrelated numbers into one.
+*/
+function effectiveConcurrency(caps) {
+	const applicable = [caps.maxLiveWorkers, caps.maxSandboxes].filter((c) => typeof c === "number" && c > 0);
+	if (applicable.length === 0) return void 0;
+	return Math.min(...applicable);
+}
+/** Convenience: a `DispatchUnit` factory over a fixed array of tasks, for the common case where
+*  the queue is known up front and only the refill behavior is wanted. */
+function queueOf(units, budget) {
+	let i = 0;
+	return () => {
+		const u = units[i];
+		if (u === void 0) return void 0;
+		i += 1;
+		return {
+			agent: u.agent,
+			task: u.task,
+			opts: {
+				budget,
+				label: u.label
+			}
+		};
+	};
+}
+//#endregion
+//#region src/runtime/supervise/progress.ts
+/** How long a worker may produce no metered activity before a `progress()` read calls it stalled.
+*  Deliberately generous: a coding harness routinely spends minutes inside one tool call, and a
+*  false stall that provokes a steer is worse than a late one. */
+const DEFAULT_STALL_AFTER_MS = 18e4;
+/** A short, already-truncated descriptor of a tool call's target — the file/command a driver
+*  needs to tell "editing the right module" from "re-reading the same file for the fifth time",
+*  without pulling the worker's transcript across the wire. Shared by every executor that fills an
+*  `ActivityLog` (pi RPC, sandbox session parts, cli-bridge tool-call deltas) so one harness's
+*  argument naming never reads differently from another's in the same driver's window. */
+function describeToolArgs(argsValue) {
+	if (!argsValue || typeof argsValue !== "object") return void 0;
+	const a = argsValue;
+	for (const key of [
+		"filePath",
+		"file_path",
+		"path",
+		"file",
+		"command",
+		"cmd",
+		"pattern"
+	]) {
+		const v = a[key];
+		if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
+	}
+}
+/** Create a bounded activity ring. `limit` caps memory for a worker that runs thousands of tools. */
+function createActivityLog(limit = 12) {
+	const notes = [];
+	const cap = Math.max(1, Math.floor(limit));
+	return {
+		push(note) {
+			notes.push(note);
+			if (notes.length > cap) notes.splice(0, notes.length - cap);
+		},
+		read: () => [...notes],
+		last: () => notes[notes.length - 1],
+		size: () => notes.length
+	};
+}
+/** Fold the scope-derived facts and the executor's optional enrichment into one read. Pure: the
+*  caller supplies `now`, so a test can observe a stall without waiting for one. */
+function readWorkerProgress(scope, executor, now, stallAfterMs = DEFAULT_STALL_AFTER_MS) {
+	const live = scope.status !== "done" && scope.status !== "failed" && scope.status !== "cancelled";
+	const executorActivityAt = executor?.recentActivity?.length ? executor.recentActivity[executor.recentActivity.length - 1].at : 0;
+	const lastActivityAt = Math.max(scope.lastActivityAt, executorActivityAt);
+	const idleMs = Math.max(0, now - lastActivityAt);
+	const note = executor?.note;
+	return {
+		id: scope.id,
+		status: scope.status,
+		live,
+		steerable: scope.steerable,
+		startedAt: scope.startedAt,
+		lastActivityAt,
+		idleMs,
+		stalled: live && idleMs > stallAfterMs,
+		stallAfterMs,
+		turns: executor?.turns ?? scope.turns,
+		tokens: scope.tokens,
+		...scope.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: scope.usd,
+		...scope.usdKnown === false ? { usdKnown: false } : {},
+		pendingMessages: executor?.pendingMessages ?? 0,
+		recentActivity: executor?.recentActivity ?? [],
+		...executor?.derived?.length ? { derived: executor.derived } : {},
+		...note ? { note } : {}
+	};
+}
+//#endregion
+//#region src/runtime/supervise/wait.ts
+/**
+*
+* WAIT-STATES — a supervision-tree node that waits on wall-clock time or an external condition
+* without holding a worker, an executor, a sandbox, or a single LLM turn.
+*
+* A long-horizon run spends most of its wall-clock NOT computing: waiting for CI to finish,
+* for a nightly job to land, for a human to reply, for a rate-limit window to reopen. Before
+* this, the only way to express that was to keep something alive and re-ask — which spends
+* driver tokens per re-ask and pins a process to the wait.
+*
+* Two node kinds, both first-class:
+*   - `timer` — wake at an ABSOLUTE wall-clock instant (`untilMs`).
+*   - `poll`  — re-run a named predicate every `intervalMs` until it returns true, or until an
+*               absolute `timeoutAtMs` passes (CI status, file existence, an HTTP probe, an
+*               inbox message).
+*
+* ── How this differs from `await_event`'s 15s poll fence (`DEFAULT_AWAIT_EVENT_TIMEOUT_MS`) ──
+*
+* They look similar and are not the same mechanism. `await_event` is an IN-RUN RENDEZVOUS: the
+* driver blocks on the coordination bus for the next event from a live worker, and the 15s fence
+* exists only so a remote MCP request does not exceed the client's timeout — the caller re-polls.
+* Every re-poll is another driver inference turn (real tokens) against a process that must stay
+* up, and nothing about that wait is recorded: kill the process and the wait is simply gone.
+*
+* A wait-state is a NODE, not a call. It has a node id in the tree, a journal record carrying its
+* ABSOLUTE deadline, and it settles through the same `Scope.next()` cursor as any worker. Nobody
+* is blocked on it — the driver can stop reasoning entirely, and the process can die. Cost while
+* waiting: zero LLM calls, zero executor, zero sandbox, zero conserved budget (a wait reserves
+* nothing from the pool). The only in-process residue is one timer entry.
+*
+* ── Why probes are NAMED, not passed as closures ────────────────────────────────────────────
+*
+* A wait must survive a process restart with its original deadline intact, and a closure cannot
+* be journaled. So a `poll` names its predicate (`probe: 'ci-green'`) and the run resolves it
+* through a `WaitProbeRegistry`. A brand-new process re-resolves the SAME name against its own
+* registry and re-arms the wait — which is what makes "kill the box, the wait keeps waiting"
+* true rather than aspirational.
+*
+* Absolute instants for the same reason: `untilMs` / `timeoutAtMs` are epoch ms, not durations,
+* so a resumed wait counts down from the original arm, not from the restart. `timerAt`/`pollFor`
+* build them from a duration when that is what the caller has.
+*
+* @experimental
+*/
+/** Build a `timer` spec from a DURATION. The instant is resolved once, at arm time — a resumed
+*  wait re-uses the journaled instant, never a fresh `now + ms`. */
+function timerAt(ms, now) {
+	return {
+		kind: "timer",
+		untilMs: now + ms
+	};
+}
+/** Build a bounded `poll` spec from a duration. */
+function pollFor(probe, opts, now) {
+	return {
+		kind: "poll",
+		probe,
+		intervalMs: opts.intervalMs,
+		...opts.timeoutMs !== void 0 ? { timeoutAtMs: now + opts.timeoutMs } : {},
+		...opts.args ? { args: opts.args } : {}
+	};
+}
+/** Registry over a plain name→predicate record. */
+function createWaitProbes(entries) {
+	const map = new Map(Object.entries(entries));
+	return { resolve: (name) => map.get(name) };
+}
+/** Narrow a settlement's `out` to a wait outcome — a wait settles on the SAME cursor as workers,
+*  so a driver that mixes them tags them apart with this. */
+function isWaitOutcome(value) {
+	return typeof value === "object" && value !== null && value.waitOutcome === true;
+}
+/** The absolute instant a spec is bounded by, or `undefined` for an unbounded poll. */
+function waitUntil(spec) {
+	return spec.kind === "timer" ? spec.untilMs : spec.timeoutAtMs;
+}
+/** Structural validation, independent of the run. Returns null when the spec is usable. */
+function validateWaitSpec(spec) {
+	if (spec.kind === "timer") return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
+	if (typeof spec.probe !== "string" || spec.probe.length === 0) return "poll.probe must be a non-empty probe name";
+	if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) return "poll.intervalMs must be > 0";
+	if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) return "poll.timeoutAtMs must be a finite epoch-ms instant";
+	return null;
+}
+/**
+* A wait must not silently outlive the run's HARD wall-clock ceiling. When the conserved pool
+* carries an absolute `deadlineMs`, a wait bounded past it — or an unbounded poll — is REFUSED at
+* arm time (`deadline-exceeded`) rather than sleeping through a ceiling the caller already set.
+* The alternative (extending the pool's deadline to cover the wait) would let a wait override a
+* hard budget guard, which is exactly what mechanic D forbids; a run that intends week-long waits
+* either sets a deadline that covers them or sets none.
+*/
+function assertWaitWithinDeadline(spec, deadlineMs) {
+	if (deadlineMs <= 0) return true;
+	const until = waitUntil(spec);
+	if (until === void 0) return false;
+	return until <= deadlineMs;
+}
+/**
+* Drive one wait to its resolution. Spends nothing: a `timer` is one sleep, a `poll` is a sleep
+* between predicate checks. No LLM call, no executor, no box, no budget reservation.
+*/
+async function runWait(args) {
+	const { spec, label, armedAt, resumed, signal, now } = args;
+	const sleep = args.sleep ?? defaultSleep;
+	if (signal.aborted) return {
+		kind: "cancelled",
+		reason: "aborted before arming"
+	};
+	if (spec.kind === "timer") {
+		const remaining = spec.untilMs - now();
+		if (remaining > 0) await sleep(remaining, signal);
+		if (signal.aborted) return {
+			kind: "cancelled",
+			reason: "wait aborted"
+		};
+		return {
+			kind: "woke",
+			outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
+		};
+	}
+	const probe = args.probes?.resolve(spec.probe);
+	if (!probe) throw new ValidationError(`wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`);
+	let polls = 0;
+	let probeErrors = 0;
+	for (;;) {
+		if (signal.aborted) return {
+			kind: "cancelled",
+			reason: "wait aborted"
+		};
+		polls += 1;
+		let fired = false;
+		try {
+			fired = await probe(spec.args, signal);
+		} catch {
+			probeErrors += 1;
+		}
+		if (fired) return {
+			kind: "woke",
+			outcome: outcome("poll", "fired", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
+		};
+		if (spec.timeoutAtMs !== void 0 && now() >= spec.timeoutAtMs) return {
+			kind: "woke",
+			outcome: outcome("poll", "timeout", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
+		};
+		await sleep(spec.timeoutAtMs === void 0 ? spec.intervalMs : Math.min(spec.intervalMs, Math.max(0, spec.timeoutAtMs - now())), signal);
+	}
+}
+function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeErrors, resumed) {
+	return {
+		waitOutcome: true,
+		kind,
+		settled,
+		label,
+		...untilMs !== void 0 ? { untilMs } : {},
+		armedAt,
+		wokenAt,
+		polls,
+		probeErrors,
+		resumed
+	};
+}
+/** `setTimeout` that resolves early (and clears) when the scope aborts, so a cancelled wait
+*  releases the event loop immediately instead of holding the process to its deadline. */
+function defaultSleep(ms, signal) {
+	if (ms <= 0 || signal.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		function onAbort() {
+			clearTimeout(timer);
+			resolve();
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/sanitize.ts
+/** Strip PII and large blobs from a `KnowledgeReadinessReport` for safe telemetry emission. @stable */
+function sanitizeKnowledgeReadinessReport(report, options = {}) {
+	return {
+		taskId: report.taskId,
 		readinessScore: report.readinessScore,
 		recommendedAction: report.recommendedAction,
 		severity: report.severity,
@@ -2830,6 +3905,94 @@ const GEN_AI = {
 	outputTokens: "gen_ai.usage.output_tokens"
 };
 /**
+* Create an exporter that APPENDS spans to a local OpenInference-JSONL file, one complete span per
+* line, instead of posting them to a collector.
+*
+* Why this exists beside {@link createOtelExporter}: that one needs an OTLP endpoint, so a run on a
+* laptop, in CI, or inside a sandbox with no collector emits nothing and its per-turn shape is
+* simply lost. The journal records the TREE (who spawned whom, what settled, what it spent); it
+* does not record what happened inside a turn. A run whose tree is readable but whose turns are not
+* is exactly the state that made an observability gap invisible until someone went looking.
+*
+* The line shape is the one `@tangle-network/traces` reads (`spans.otlp.jsonl`) and is a standard
+* OpenInference representation, so the same file feeds any OpenInference tool with no conversion:
+* snake_case identity fields, ISO-8601 times, `parent_span_id` empty at the root, and attributes as
+* a plain object rather than OTLP's key/value array.
+*
+* Appends synchronously per span so a killed process keeps every span it had already finished —
+* matching the spawn journal's durability posture, since a trace that only survives a clean exit is
+* useless for the runs you most want to look at.
+*/
+function createOpenInferenceFileExporter(filePath) {
+	const lines = [];
+	let failed;
+	const append = (line) => {
+		try {
+			appendFileSync(filePath, `${line}\n`, "utf8");
+		} catch (error) {
+			failed ??= error instanceof Error ? error : new Error(String(error));
+		}
+	};
+	return {
+		exportSpan(span) {
+			append(JSON.stringify(toOpenInferenceLine(span)));
+			lines.push("");
+		},
+		async flush() {
+			if (failed) throw new Error(`OpenInference file exporter failed writing ${filePath}: ${failed.message}`);
+		},
+		async shutdown() {
+			lines.length = 0;
+		}
+	};
+}
+/** OTLP's numeric status codes in the NAMES OpenInference requires. */
+const OTEL_STATUS_NAME = {
+	0: "UNSET",
+	1: "OK",
+	2: "ERROR"
+};
+/** Nanosecond string -> ISO-8601, the time format an OpenInference reader parses with `Date.parse`. */
+function nanosToIso(nanos) {
+	const ms = Number(BigInt(nanos) / 1000000n);
+	return new Date(ms).toISOString();
+}
+/** OTLP's key/value attribute array -> the plain object OpenInference carries. */
+function attributesToObject(attributes) {
+	const out = {};
+	for (const a of attributes ?? []) {
+		const v = a.value;
+		out[a.key] = v.stringValue ?? (v.intValue !== void 0 ? Number(v.intValue) : void 0) ?? v.doubleValue ?? v.boolValue;
+	}
+	return out;
+}
+/** One `OtelSpan` as the OpenInference JSONL line `traces` and other OpenInference tools read. */
+function toOpenInferenceLine(span) {
+	const attributes = attributesToObject(span.attributes);
+	const kind = attributes["openinference.span.kind"];
+	const resource = {};
+	for (const key of ["service.name", "agent.name"]) if (attributes[key] !== void 0) resource[key] = attributes[key];
+	return {
+		trace_id: span.traceId,
+		span_id: span.spanId,
+		parent_span_id: span.parentSpanId ?? "",
+		name: span.name,
+		kind: typeof kind === "string" ? kind : "CHAIN",
+		start_time: nanosToIso(span.startTimeUnixNano),
+		end_time: nanosToIso(span.endTimeUnixNano),
+		status: {
+			code: OTEL_STATUS_NAME[span.status?.code ?? 0] ?? "UNSET",
+			...span.status?.message === void 0 ? {} : { message: span.status.message }
+		},
+		resource: { attributes: resource },
+		scope: {
+			name: "agent-runtime",
+			version: ""
+		},
+		attributes
+	};
+}
+/**
 * Create an OTEL exporter. Returns undefined when no endpoint is configured.
 */
 function createOtelExporter(config) {
@@ -3380,7 +4543,7 @@ function generateTraceId() {
 * PRECEDENCE, from lowest to highest:
 *   1. the supervisor process's own `process.env` (ambient inheritance),
 *   2. the trace context stamped here,
-*   3. the caller's own seam env (`PiSeam.env`, `CliSeam.env`).
+*   3. the caller's own seam env (`CliSeam.env`).
 * A caller who sets `TRACE_ID` / `PARENT_SPAN_ID` on a seam wins — theirs is a deliberate
 * declaration about the worker. Ambient `process.env` does NOT win: when the supervisor process was
 * itself launched as someone's worker, its inherited ids describe the SUPERVISOR's place in an
@@ -3391,7 +4554,6 @@ function generateTraceId() {
 *
 * WHICH BACKENDS PROPAGATE. Only a backend with a real environment channel to the worker can carry
 * this, and the ones that cannot say so here rather than dropping it silently:
-*   - `pi`            YES — `PiSeam.env` → the `pi --mode rpc` subprocess.
 *   - `cli`           YES — `CliSeam.env` → the spawned subprocess.
 *   - `sandbox`       YES — `CreateSandboxOptions.env` on the box the worker runs in (single-shot
 *                     and steerable). This is the cross-MACHINE case the feature exists for.
@@ -3464,30 +4626,38 @@ function workerTraceEnv(ctx) {
 /**
 * The recursion seam key. A `Scope` seeds a value of this on each child's
 * `ExecutorContext.seams` so a child whose executor is a DRIVER can mount a NESTED `Scope`
-* over the SAME conserved pool at `depth+1`. A leaf executor never reads it. Single-sourced
+* over the driver's reserved child allocation at `depth+1`. A leaf executor never reads it. Single-sourced
 * here so the scope and the driver-executor agree on the seam without a circular import.
 */
 const nestedScopeSeamKey = "nested-scope";
-function makeNestedScopeSeam(args, childNodeId) {
+function makeNestedScopeSeam(args, liveWorkerCapacity, childNodeId, childBudget, childDeadlineAtMs, deferredOwner) {
+	const now = args.now ?? Date.now;
 	return {
+		nodeId: childNodeId,
 		depth: args.depth,
 		...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
 		journalRoot: args.root,
 		mount(nestedRoot, signal) {
+			const deadlineMs = childDeadlineAtMs === void 0 ? void 0 : Math.max(0, childDeadlineAtMs - now());
 			return createScope({
 				parentId: childNodeId,
 				root: nestedRoot,
-				pool: args.pool,
+				pool: createBudgetPool({
+					...childBudget,
+					...deadlineMs !== void 0 ? { deadlineMs } : {}
+				}, now),
 				journal: args.journal,
 				blobs: args.blobs,
 				executors: args.executors,
 				seams: args.seams,
 				depth: args.depth + 1,
 				...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
+				liveWorkerCapacity,
 				signal,
 				...args.now ? { now: args.now } : {},
 				...args.hooks ? { hooks: args.hooks } : {},
-				...args.workerTrace ? { workerTrace: args.workerTrace } : {}
+				...args.workerTrace ? { workerTrace: args.workerTrace } : {},
+				...deferredOwner.ownerMaterialization === void 0 ? {} : { ownerMaterialization: deferredOwner.ownerMaterialization }
 			});
 		}
 	};
@@ -3495,6 +4665,10 @@ function makeNestedScopeSeam(args, childNodeId) {
 /** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
 function createScope(args) {
 	const children = /* @__PURE__ */ new Map();
+	const liveWorkerCapacity = args.liveWorkerCapacity ?? {
+		max: normalizeLiveWorkerLimit(args.maxLiveWorkers),
+		live: 0
+	};
 	let spawnOrdinal = args.resumeFrom ? args.resumeFrom.maxSpawnOrdinal + 1 : 0;
 	let cursorSeq = args.resumeFrom ? args.resumeFrom.maxCursorSeq + 1 : 0;
 	let waitOrdinal = args.resumeFrom ? args.resumeFrom.maxWaitOrdinal + 1 : 0;
@@ -3502,38 +4676,78 @@ function createScope(args) {
 	const now = args.now ?? Date.now;
 	const unclaimedWaits = new Map((args.resumeFrom?.waits ?? []).map((w) => [w.label, w]));
 	const keyed = /* @__PURE__ */ new Map();
-	for (const [key, prior] of args.resumeFrom?.keys ?? []) if (prior.state === "completed" && prior.settled?.kind === "done") keyed.set(key, {
-		state: "done",
-		id: prior.id,
-		settled: prior.settled
-	});
-	else if (prior.state === "down" && prior.settled?.kind === "down") keyed.set(key, {
-		state: "down",
-		id: prior.id,
-		reason: prior.settled.reason
-	});
-	else keyed.set(key, {
+	for (const [key, prior] of args.resumeFrom?.keys ?? []) if (prior.state === "completed" && prior.settled?.kind === "done") {
+		if (prior.identity === void 0) continue;
+		keyed.set(key, {
+			state: "done",
+			id: prior.id,
+			identity: prior.identity,
+			settled: prior.settled
+		});
+	} else if (prior.state === "down" && prior.settled?.kind === "down") {
+		if (prior.identity === void 0) continue;
+		keyed.set(key, {
+			state: "down",
+			id: prior.id,
+			identity: prior.identity,
+			reason: prior.settled.reason
+		});
+	} else if (prior.identity !== void 0) keyed.set(key, {
 		state: "in-doubt",
-		id: prior.id
+		id: prior.id,
+		identity: prior.identity
 	});
 	/** Fold a keyed child's terminal settlement back into the registry, so a later spawn with the
 	*  same key resolves to it (done → committed result; down → explicit retry). */
 	const recordKeyedSettlement = (key, settled) => {
+		const identity = settled.handle.identity;
+		if (identity === void 0) throw new ValidationError(`scope: keyed settlement '${key}' lost its execution identity`);
 		if (settled.kind === "done") keyed.set(key, {
 			state: "done",
 			id: settled.handle.id,
+			identity,
 			settled
 		});
 		else keyed.set(key, {
 			state: "down",
 			id: settled.handle.id,
+			identity,
 			reason: settled.reason
 		});
 	};
-	function spawn(agent, task, opts) {
+	function spawn(agentOrFactory, rawTask, rawOpts) {
+		if (args.signal.aborted) return {
+			ok: false,
+			reason: "scope-aborted"
+		};
+		const task = detachedSnapshot(rawTask, "scope.spawn task");
+		const opts = detachedSnapshot(rawOpts, "scope.spawn options");
 		let prior;
+		let prepared;
+		const prepare = () => {
+			const agent = typeof agentOrFactory === "function" ? agentOrFactory() : agentOrFactory;
+			const rawSpec = agent.executorSpec;
+			if (!isAgentSpec(rawSpec)) throw new ValidationError(`scope.spawn: agent "${agent.name}" exposes no \`executorSpec\` (AgentSpec) to resolve a Executor`);
+			const spec = snapshotAgentSpec(rawSpec);
+			return {
+				agent,
+				spec,
+				identity: deriveNodeExecutionIdentity(spec, task)
+			};
+		};
 		if (opts.key !== void 0) {
 			const existing = keyed.get(opts.key);
+			if (existing !== void 0) {
+				prepared = prepare();
+				if (!isCompleteIdentity(prepared.identity)) return {
+					ok: false,
+					reason: "invalid-identity"
+				};
+				if (!sameNodeExecutionIdentity(existing.identity, prepared.identity)) return {
+					ok: false,
+					reason: "key-conflict"
+				};
+			}
 			if (existing?.state === "live") return {
 				ok: false,
 				reason: "duplicate-key"
@@ -3560,74 +4774,203 @@ function createScope(args) {
 			ok: false,
 			reason: "depth-exceeded"
 		};
-		const spec = agent.executorSpec;
-		if (!isAgentSpec(spec)) throw new ValidationError(`scope.spawn: agent "${agent.name}" exposes no \`executorSpec\` (AgentSpec) to resolve a Executor`);
-		const resolved = args.executors.resolve(spec);
-		if (!resolved.succeeded) throw new ValidationError(`scope.spawn: ${resolved.error}`);
-		const reservation = args.pool.reserve(opts.budget);
-		if (!reservation.ok) return {
+		const permit = acquireLiveWorker(liveWorkerCapacity);
+		if (!permit.ok) return {
 			ok: false,
-			reason: reservation.reason
+			reason: "max-live-workers"
 		};
+		let reservation;
+		try {
+			reservation = args.pool.reserve(opts.budget);
+		} catch (error) {
+			permit.release();
+			throw error;
+		}
+		if (!reservation.ok) {
+			permit.release();
+			return {
+				ok: false,
+				reason: reservation.reason
+			};
+		}
+		let spec;
+		let resolved;
+		let identity;
+		try {
+			prepared ??= prepare();
+			spec = prepared.spec;
+			identity = prepared.identity;
+			if (opts.key !== void 0 && !isCompleteIdentity(identity)) {
+				args.pool.reconcile(reservation.ticket, zeroSpend$1());
+				permit.release();
+				return {
+					ok: false,
+					reason: "invalid-identity"
+				};
+			}
+			const floor = workerTokenFloor(spec.harness ?? spec.profile.harness ?? null);
+			if (floor !== null && opts.budget.maxTokens < floor) {
+				args.pool.reconcile(reservation.ticket, zeroSpend$1());
+				permit.release();
+				return {
+					ok: false,
+					reason: "below-runtime-floor"
+				};
+			}
+			const outcome = args.executors.resolve(spec);
+			if (!outcome.succeeded) throw new ValidationError(`scope.spawn: ${outcome.error}`);
+			resolved = outcome;
+		} catch (error) {
+			args.pool.reconcile(reservation.ticket, zeroSpend$1());
+			permit.release();
+			throw error;
+		}
+		let cascadeAbort;
+		let clearChildDeadline;
 		try {
 			const ordinal = spawnOrdinal++;
 			const id = `${args.parentId}:s${ordinal}`;
-			const childAbort = new AbortController();
-			const cascadeAbort = () => childAbort.abort();
-			if (args.signal.aborted) childAbort.abort();
+			const attemptId = newExecutionAttemptId(id);
+			const startedAt = now();
+			const childDeadlineAtMs = boundedChildDeadlineAt(args.pool.readout().deadlineMs, opts.budget.deadlineMs, startedAt);
+			const controller = new AbortController();
+			cascadeAbort = () => controller.abort(args.signal.reason);
+			if (args.signal.aborted) controller.abort(args.signal.reason);
 			else args.signal.addEventListener("abort", cascadeAbort, { once: true });
+			if (childDeadlineAtMs !== void 0) clearChildDeadline = armDeadlineTimer(Math.max(0, childDeadlineAtMs - now()), () => controller.abort("child deadline exceeded"));
+			const deferredOwner = {};
 			const workerTrace = args.workerTrace?.(args.parentId);
 			const ctx = {
-				signal: childAbort.signal,
+				signal: controller.signal,
+				node: {
+					rootId: args.root,
+					parentId: args.parentId,
+					nodeId: id,
+					attemptId,
+					...identity ? { identity } : {}
+				},
 				seams: {
 					...args.seams,
-					[nestedScopeSeamKey]: makeNestedScopeSeam(args, id),
+					[nestedScopeSeamKey]: makeNestedScopeSeam(args, liveWorkerCapacity, id, opts.budget, childDeadlineAtMs, deferredOwner),
 					...workerTrace ? { [workerTraceSeamKey]: workerTrace } : {}
 				}
 			};
 			const executor = resolved.value(spec, ctx);
+			const ownedTreeRoot = runtimeOwnedNestedDriverTreeRoot(executor, args.root, id);
 			const handle = {
 				id,
 				label: opts.label,
+				...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
+				...identity ? { identity } : {},
 				get status() {
 					return children.get(id)?.status ?? "cancelled";
 				},
+				get materialization() {
+					return children.get(id)?.materialization;
+				},
+				get executionBindings() {
+					const bindings = children.get(id)?.executionBindings;
+					return bindings && bindings.length > 0 ? Object.freeze([...bindings]) : void 0;
+				},
 				abort(reason) {
-					childAbort.abort(reason);
+					controller.abort(reason);
 				}
 			};
 			const live = {
 				id,
 				status: "acquiring",
 				runtime: executor.runtime,
+				...ownedTreeRoot === void 0 ? {} : { ownedTreeRoot },
+				...identity ? { identity } : {},
 				budget: opts.budget,
 				label: opts.label,
+				...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
 				...opts.key !== void 0 ? { key: opts.key } : {},
-				spent: zeroSpend(),
+				spent: zeroSpend$1(),
 				settled: void 0,
 				delivered: false,
 				executorDone: false,
-				startedAt: now(),
-				lastActivityAt: now(),
-				...executor.deliver ? { deliver: executor.deliver.bind(executor) } : {},
+				cleanupConfirmed: false,
+				executionBindings: [],
+				startedAt,
+				lastActivityAt: startedAt,
+				...executor.deliver ? { deliver: (message) => executor.deliver?.(message) !== false } : {},
 				...executor.progress ? { readProgress: executor.progress.bind(executor) } : {},
 				...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {}
 			};
 			children.set(id, live);
 			if (opts.key !== void 0) keyed.set(opts.key, {
 				state: "live",
-				id
+				id,
+				identity
 			});
-			args.journal.appendEvent(args.root, {
+			const materializationCommitted = args.journal.appendEvent(args.root, {
 				kind: "spawned",
 				id,
 				parent: args.parentId,
 				label: opts.label,
 				...opts.key !== void 0 ? { key: opts.key } : {},
+				...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
 				budget: opts.budget,
 				runtime: executor.runtime,
+				...ownedTreeRoot === void 0 ? {} : { ownedTreeRoot },
+				...identity ? { identity } : {},
 				seq: ordinal,
 				at: new Date(now()).toISOString()
+			}).then(async () => {
+				const profileDigest = identity?.profileDigest ?? authoredProfileDigest(spec.profile);
+				let receipt;
+				let binding;
+				const declaration = runtimeOwnedExecutorMaterialization(executor);
+				const deferredRuntime = runtimeOwnedDeferredExecutorRuntime(executor);
+				if (deferredRuntime !== void 0) {
+					deferredOwner.ownerMaterialization = {
+						runtime: deferredRuntime,
+						authoredProfile: spec.profile,
+						attemptId,
+						journalRoot: args.root,
+						nodeId: id,
+						requiredKnown: true,
+						onReceipt(materialization, executionBinding) {
+							live.runtime = materialization.runtime;
+							live.materialization = materialization;
+							live.executionBindings.push(executionBinding);
+						}
+					};
+					return;
+				}
+				if (declaration === void 0) {
+					receipt = unknownMaterializationReceipt({
+						...profileDigest === void 0 ? {} : { authoredProfileDigest: profileDigest },
+						runtime: executor.runtime,
+						reason: "executor-did-not-report"
+					});
+					binding = unknownExecutionBindingReceipt(receipt, attemptId, "executor-did-not-report");
+				} else try {
+					if (profileDigest === void 0) throw new ValidationError("scope.spawn: a known materialization requires a canonical authored profile");
+					receipt = knownMaterializationReceipt({
+						authoredProfileDigest: profileDigest,
+						runtime: executor.runtime,
+						declaration
+					});
+					const reportedBinding = runtimeOwnedExecutorExecutionBinding(executor);
+					if (reportedBinding === void 0 || reportedBinding.attemptId !== attemptId) throw new ValidationError("scope.spawn: trusted executor did not bind the kernel-minted attempt id");
+					binding = knownExecutionBindingReceipt(receipt, reportedBinding);
+				} catch (error) {
+					receipt = unknownMaterializationReceipt({
+						...profileDigest === void 0 ? {} : { authoredProfileDigest: profileDigest },
+						runtime: executor.runtime,
+						reason: "invalid-executor-report"
+					});
+					binding = unknownExecutionBindingReceipt(receipt, attemptId, "invalid-executor-report");
+					await appendNodeMaterialization(args, id, ordinal, receipt, binding, now);
+					live.materialization = receipt;
+					live.executionBindings.push(binding);
+					throw new ValidationError(`scope.spawn: executor ${JSON.stringify(executor.runtime)} returned invalid materialization evidence`, { cause: error });
+				}
+				await appendNodeMaterialization(args, id, ordinal, receipt, binding, now);
+				live.materialization = receipt;
+				live.executionBindings.push(binding);
 			});
 			notifyRuntimeHookEvent(args.hooks, {
 				id: `${id}:spawn`,
@@ -3640,16 +4983,20 @@ function createScope(args) {
 				payload: {
 					childId: id,
 					label: opts.label,
+					...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
 					runtime: executor.runtime,
+					...identity ? { identity } : {},
 					budget: opts.budget,
 					depth: args.depth
 				}
 			}, { signal: args.signal });
-			live.settled = runChild(live, executor, childAbort, task, opts, args.pool, reservation.ticket, args.blobs, now).then((s) => {
+			live.settled = runChild(live, executor, controller, task, opts, args.pool, reservation.ticket, args.blobs, now, materializationCommitted, childDeadlineAtMs).then((s) => {
 				live.resolved = s;
 				return s;
 			}).finally(() => {
-				args.signal.removeEventListener("abort", cascadeAbort);
+				if (live.cleanupConfirmed) permit.release();
+				clearChildDeadline?.();
+				if (cascadeAbort) args.signal.removeEventListener("abort", cascadeAbort);
 			});
 			return {
 				ok: true,
@@ -3657,7 +5004,10 @@ function createScope(args) {
 				...prior ? { prior } : {}
 			};
 		} catch (err) {
-			args.pool.reconcile(reservation.ticket, zeroSpend());
+			permit.release();
+			clearChildDeadline?.();
+			if (cascadeAbort) args.signal.removeEventListener("abort", cascadeAbort);
+			args.pool.reconcile(reservation.ticket, zeroSpend$1());
 			throw err;
 		}
 	}
@@ -3692,9 +5042,10 @@ function createScope(args) {
 		}
 	}
 	function send(nodeId, msg) {
+		if (args.signal.aborted) return false;
 		const child = children.get(nodeId);
 		if (!child || child.delivered || !child.deliver) return false;
-		child.deliver(msg);
+		if (!(child.deliver(msg) !== false)) return false;
 		child.lastActivityAt = now();
 		return true;
 	}
@@ -3709,6 +5060,10 @@ function createScope(args) {
 	* extend that ceiling either (that would make a wait override a budget guard).
 	*/
 	function wait(spec, opts) {
+		if (args.signal.aborted) return {
+			ok: false,
+			reason: "deadline-exceeded"
+		};
 		if (validateWaitSpec(spec) !== null) return {
 			ok: false,
 			reason: "invalid-spec"
@@ -3751,20 +5106,23 @@ function createScope(args) {
 				maxTokens: 0
 			},
 			label: opts.label,
-			spent: zeroSpend(),
+			spent: zeroSpend$1(),
 			settled: void 0,
 			delivered: false,
 			executorDone: false,
+			cleanupConfirmed: true,
+			executionBindings: [],
 			startedAt: armedAt,
 			lastActivityAt: now(),
 			wait: {
 				spec: effectiveSpec,
 				armedAt,
-				label: opts.label
+				label: opts.label,
+				armCommitted: adopted !== void 0
 			}
 		};
 		children.set(id, live);
-		if (!adopted) args.journal.appendEvent(args.root, {
+		live.settled = (adopted ? Promise.resolve() : args.journal.appendEvent(args.root, {
 			kind: "waiting",
 			id,
 			parent: args.parentId,
@@ -3773,33 +5131,35 @@ function createScope(args) {
 			armedAt,
 			seq: ordinal,
 			at: new Date(now()).toISOString()
-		});
-		notifyRuntimeHookEvent(args.hooks, {
-			id: `${id}:waiting`,
-			runId: args.root,
-			target: "agent.spawn",
-			phase: "after",
-			timestamp: now(),
-			stepIndex: ordinal,
-			parentId: args.parentId,
-			payload: {
-				childId: id,
+		})).then(() => {
+			if (live.wait) live.wait.armCommitted = true;
+			notifyRuntimeHookEvent(args.hooks, {
+				id: `${id}:waiting`,
+				runId: args.root,
+				target: "agent.spawn",
+				phase: "after",
+				timestamp: now(),
+				stepIndex: ordinal,
+				parentId: args.parentId,
+				payload: {
+					childId: id,
+					label: opts.label,
+					runtime: "wait",
+					wait: effectiveSpec,
+					armedAt,
+					resumed: adopted !== void 0
+				}
+			}, { signal: args.signal });
+			return runWait({
+				spec: effectiveSpec,
 				label: opts.label,
-				runtime: "wait",
-				wait: effectiveSpec,
 				armedAt,
-				resumed: adopted !== void 0
-			}
-		}, { signal: args.signal });
-		live.settled = runWait({
-			spec: effectiveSpec,
-			label: opts.label,
-			armedAt,
-			resumed: adopted !== void 0,
-			signal: waitAbort.signal,
-			...args.probes ? { probes: args.probes } : {},
-			now,
-			...args.waitSleep ? { sleep: args.waitSleep } : {}
+				resumed: adopted !== void 0,
+				signal: waitAbort.signal,
+				...args.probes ? { probes: args.probes } : {},
+				now,
+				...args.waitSleep ? { sleep: args.waitSleep } : {}
+			});
 		}).then(async (resolution) => {
 			live.executorDone = true;
 			live.lastActivityAt = now();
@@ -3807,7 +5167,11 @@ function createScope(args) {
 				kind: "down",
 				reason: resolution.reason,
 				infra: false,
-				restartCount: 0
+				restartCount: 0,
+				trace: {
+					status: "unavailable",
+					reason: "not-an-executor"
+				}
 			};
 			const outRef = contentAddress(resolution.outcome);
 			await args.blobs.put(outRef, resolution.outcome);
@@ -3815,7 +5179,11 @@ function createScope(args) {
 				kind: "done",
 				out: resolution.outcome,
 				outRef,
-				spent: zeroSpend()
+				spent: zeroSpend$1(),
+				trace: {
+					status: "unavailable",
+					reason: "not-an-executor"
+				}
 			};
 		}).catch((err) => {
 			live.executorDone = true;
@@ -3823,7 +5191,11 @@ function createScope(args) {
 				kind: "down",
 				reason: errMessage(err),
 				infra: true,
-				restartCount: 0
+				restartCount: 0,
+				trace: {
+					status: "unavailable",
+					reason: "not-an-executor"
+				}
 			};
 		}).then((s) => {
 			live.resolved = s;
@@ -3868,8 +5240,14 @@ function createScope(args) {
 		}
 	}
 	async function meter(spend, detail) {
+		if (args.signal.aborted) throw new ValidationError("scope.meter: cannot record new driver work after scope abort");
 		const seq = meterSeq++;
-		args.pool.observe(spend);
+		let observeError;
+		try {
+			args.pool.observe(spend);
+		} catch (error) {
+			observeError = error;
+		}
 		await args.journal.appendEvent(args.root, {
 			kind: "metered",
 			id: args.parentId,
@@ -3889,6 +5267,7 @@ function createScope(args) {
 				...detail ?? {}
 			}
 		}, { signal: args.signal });
+		if (observeError !== void 0) throw observeError;
 	}
 	const resume = args.resumeFrom ? {
 		settled: args.resumeFrom.settled,
@@ -3897,7 +5276,7 @@ function createScope(args) {
 		keys: args.resumeFrom.keys,
 		priorSpend: args.resumeFrom.priorSpend
 	} : void 0;
-	return {
+	const scope = {
 		spawn,
 		next,
 		nextResolved,
@@ -3913,8 +5292,177 @@ function createScope(args) {
 		},
 		get budget() {
 			return args.pool.readout();
+		},
+		get workerCapacity() {
+			return {
+				live: liveWorkerCapacity.live,
+				freeSlots: freeSlots(liveWorkerCapacity.live, liveWorkerCapacity.max)
+			};
 		}
 	};
+	if (args.ownerMaterialization !== void 0) {
+		const authoredProfile = args.ownerMaterialization.authoredProfile === void 0 ? void 0 : detachedSnapshot(args.ownerMaterialization.authoredProfile, "scope owner authored profile");
+		ownerMaterializationStates.set(scope, {
+			journal: args.journal,
+			root: args.ownerMaterialization.journalRoot ?? args.root,
+			nodeId: args.ownerMaterialization.nodeId ?? args.parentId,
+			runtime: args.ownerMaterialization.runtime,
+			attemptId: args.ownerMaterialization.attemptId,
+			...authoredProfile === void 0 ? {} : { authoredProfile },
+			...authoredProfile === void 0 ? {} : { authoredProfileDigest: authoredProfileDigest(authoredProfile) },
+			...args.ownerMaterialization.prior === void 0 ? {} : { prior: args.ownerMaterialization.prior },
+			requiredKnown: args.ownerMaterialization.requiredKnown === true,
+			...args.ownerMaterialization.onReceipt === void 0 ? {} : { onReceipt: args.ownerMaterialization.onReceipt },
+			now,
+			receipt: args.ownerMaterialization.prior,
+			bindingPublished: false,
+			publishedThisProcess: false
+		});
+	}
+	return scope;
+}
+const ownerMaterializationStates = /* @__PURE__ */ new WeakMap();
+/**
+* @internal Publish exact root-manager materialization from a runtime-owned adapter after dynamic
+* attachments exist and before its executor starts. This is deliberately a module function backed
+* by a private WeakMap, not a Scope method an Agent can call.
+*/
+async function recordScopeOwnerMaterialization(scope, runtime, declaration, bindingInput) {
+	const state = ownerMaterializationState(scope);
+	if (runtime !== state.runtime) {
+		await rejectOwnerMaterialization(state);
+		throw new ValidationError(`scope owner materialization runtime ${JSON.stringify(runtime)} does not match ${JSON.stringify(state.runtime)}`);
+	}
+	if (state.authoredProfileDigest === void 0) {
+		await rejectOwnerMaterialization(state);
+		throw new ValidationError("scope owner materialization requires an exact authored profile");
+	}
+	let receipt;
+	let binding;
+	try {
+		if (bindingInput.attemptId !== state.attemptId) throw new ValidationError("scope owner execution binding does not use the kernel-minted attempt id");
+		if (canonicalCandidateDigest(declaration.effectiveProfile) !== state.authoredProfileDigest) throw new ValidationError("scope owner stable effective profile conflicts with its admitted authored profile");
+		receipt = knownMaterializationReceipt({
+			authoredProfileDigest: state.authoredProfileDigest,
+			runtime,
+			declaration
+		});
+		binding = knownExecutionBindingReceipt(receipt, bindingInput);
+	} catch (error) {
+		await rejectOwnerMaterialization(state);
+		throw new ValidationError("scope owner returned invalid materialization evidence", { cause: error });
+	}
+	if (state.prior !== void 0) {
+		if (canonicalCandidateDigest(state.prior) !== canonicalCandidateDigest(receipt)) {
+			await rejectOwnerMaterialization(state);
+			throw new ValidationError("scope owner materialization changed across resume; backend, model, execution identity, and plan must match");
+		}
+		state.receipt = state.prior;
+		await appendOwnerBinding(state, binding);
+		state.onReceipt?.(state.prior, binding);
+		state.publishedThisProcess = true;
+		return;
+	}
+	if (state.receipt !== void 0) throw new ValidationError("scope owner materialization was already recorded");
+	await appendOwnerMaterialization(state, receipt, binding);
+	state.onReceipt?.(receipt, binding);
+	state.publishedThisProcess = true;
+}
+/** @internal Kernel identity for constructing the exact deferred owner executor. */
+function scopeOwnerExecutorNodeContext(scope) {
+	const state = ownerMaterializationState(scope);
+	return Object.freeze({
+		rootId: state.root,
+		parentId: state.nodeId,
+		nodeId: state.nodeId,
+		attemptId: state.attemptId
+	});
+}
+/** @internal Ensure a deferred root that never published evidence remains visibly unknown. */
+async function finalizeScopeOwnerMaterialization(scope) {
+	const state = ownerMaterializationStates.get(scope);
+	if (state === void 0 || state.publishedThisProcess) return;
+	if (state.prior !== void 0) {
+		await appendUnknownOwnerBinding(state, state.prior, "root-agent-did-not-report");
+		throw new ValidationError("resumed scope owner did not re-attest its prior materialization before execution");
+	}
+	if (state.receipt !== void 0) return;
+	const receipt = unknownMaterializationReceipt({
+		...state.authoredProfileDigest === void 0 ? {} : { authoredProfileDigest: state.authoredProfileDigest },
+		runtime: state.runtime,
+		reason: "root-agent-did-not-report"
+	});
+	const binding = unknownExecutionBindingReceipt(receipt, state.attemptId, "root-agent-did-not-report");
+	await appendOwnerMaterialization(state, receipt, binding);
+	state.onReceipt?.(receipt, binding);
+	if (state.requiredKnown) throw new ValidationError("runtime-owned scope owner did not publish materialization before completing");
+}
+function ownerMaterializationState(scope) {
+	const state = ownerMaterializationStates.get(scope);
+	if (state === void 0) throw new ValidationError("scope has no deferred runtime-owned root materialization channel");
+	return state;
+}
+async function rejectOwnerMaterialization(state) {
+	if (state.bindingPublished) return;
+	if (state.prior !== void 0) {
+		await appendUnknownOwnerBinding(state, state.prior, "invalid-executor-report");
+		return;
+	}
+	if (state.receipt !== void 0) {
+		await appendUnknownOwnerBinding(state, state.receipt, "invalid-executor-report");
+		return;
+	}
+	const receipt = unknownMaterializationReceipt({
+		...state.authoredProfileDigest === void 0 ? {} : { authoredProfileDigest: state.authoredProfileDigest },
+		runtime: state.runtime,
+		reason: "invalid-executor-report"
+	});
+	const binding = unknownExecutionBindingReceipt(receipt, state.attemptId, "invalid-executor-report");
+	await appendOwnerMaterialization(state, receipt, binding);
+	state.onReceipt?.(receipt, binding);
+}
+async function appendOwnerMaterialization(state, receipt, binding) {
+	await state.journal.appendEvent(state.root, {
+		kind: "materialized",
+		id: state.nodeId,
+		receipt,
+		seq: 0,
+		at: new Date(state.now()).toISOString()
+	});
+	state.receipt = receipt;
+	await appendOwnerBinding(state, binding);
+}
+async function appendOwnerBinding(state, binding) {
+	await state.journal.appendEvent(state.root, {
+		kind: "execution-bound",
+		id: state.nodeId,
+		binding,
+		seq: 0,
+		at: new Date(state.now()).toISOString()
+	});
+	state.bindingPublished = true;
+}
+async function appendUnknownOwnerBinding(state, receipt, reason) {
+	const binding = unknownExecutionBindingReceipt(receipt, state.attemptId, reason);
+	await appendOwnerBinding(state, binding);
+	state.onReceipt?.(receipt, binding);
+}
+async function appendNodeMaterialization(args, id, seq, receipt, binding, now) {
+	const at = new Date(now()).toISOString();
+	await args.journal.appendEvent(args.root, {
+		kind: "materialized",
+		id,
+		receipt,
+		seq,
+		at
+	});
+	await args.journal.appendEvent(args.root, {
+		kind: "execution-bound",
+		id,
+		binding,
+		seq,
+		at
+	});
 }
 /** Await whichever pending child settles first, returning the child (its `resolved` is set
 *  by the time this resolves because `runChild`'s `.then` sets it before the promise
@@ -3927,30 +5475,36 @@ async function raceFirstSettled(pending) {
 async function finalizeSettlement(child, settlement, seq, args, now) {
 	const handle = frozenHandle(child);
 	if (child.wait) return finalizeWait(child, settlement, seq, args, now, handle);
+	const settledAt = now();
+	child.settledAt = settledAt;
+	const at = new Date(settledAt).toISOString();
 	if (settlement.kind === "down") {
 		child.status = "failed";
+		child.trace = settlement.trace;
 		await args.journal.appendEvent(args.root, {
 			kind: "settled",
 			id: child.id,
 			status: "down",
 			spent: child.spent,
 			infra: settlement.infra,
+			reason: settlement.reason,
+			trace: settlement.trace,
 			seq,
-			at: new Date(now()).toISOString()
+			at
 		});
 		if (settlement.metered) await args.journal.appendEvent(args.root, {
 			kind: "metered",
 			id: child.id,
 			spend: settlement.metered,
 			seq,
-			at: new Date(now()).toISOString()
+			at
 		});
 		notifyRuntimeHookEvent(args.hooks, {
 			id: `${child.id}:settled`,
 			runId: args.root,
 			target: "agent.child",
 			phase: "after",
-			timestamp: now(),
+			timestamp: settledAt,
 			stepIndex: seq,
 			parentId: args.parentId,
 			payload: {
@@ -3967,12 +5521,15 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 			reason: settlement.reason,
 			infra: settlement.infra,
 			restartCount: settlement.restartCount,
+			trace: settlement.trace,
+			settledAt,
 			seq
 		};
 	}
 	child.status = "done";
 	child.outRef = settlement.outRef;
 	child.spent = settlement.spent;
+	child.trace = settlement.trace;
 	await args.journal.appendEvent(args.root, {
 		kind: "settled",
 		id: child.id,
@@ -3980,22 +5537,23 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		outRef: settlement.outRef,
 		...settlement.verdict ? { verdict: settlement.verdict } : {},
 		spent: settlement.spent,
+		trace: settlement.trace,
 		seq,
-		at: new Date(now()).toISOString()
+		at
 	});
 	if (settlement.metered) await args.journal.appendEvent(args.root, {
 		kind: "metered",
 		id: child.id,
 		spend: settlement.metered,
 		seq,
-		at: new Date(now()).toISOString()
+		at
 	});
 	notifyRuntimeHookEvent(args.hooks, {
 		id: `${child.id}:settled`,
 		runId: args.root,
 		target: "agent.child",
 		phase: "after",
-		timestamp: now(),
+		timestamp: settledAt,
 		stepIndex: seq,
 		parentId: args.parentId,
 		payload: {
@@ -4014,6 +5572,8 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		outRef: settlement.outRef,
 		...settlement.verdict ? { verdict: settlement.verdict } : {},
 		spent: settlement.spent,
+		trace: settlement.trace,
+		settledAt,
 		seq
 	};
 }
@@ -4021,10 +5581,12 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 *  the driver branches on. `by` names WHY it woke — `fired` / `timeout` / `cancelled` — which is
 *  the fact a resumed reader needs and cannot recover from a payload it may never fetch. */
 async function finalizeWait(child, settlement, seq, args, now, handle) {
-	const at = new Date(now()).toISOString();
+	const settledAt = now();
+	child.settledAt = settledAt;
+	const at = new Date(settledAt).toISOString();
 	if (settlement.kind === "down") {
 		child.status = "cancelled";
-		await args.journal.appendEvent(args.root, {
+		if (child.wait?.armCommitted) await args.journal.appendEvent(args.root, {
 			kind: "woken",
 			id: child.id,
 			by: "cancelled",
@@ -4037,6 +5599,8 @@ async function finalizeWait(child, settlement, seq, args, now, handle) {
 			reason: settlement.reason,
 			infra: settlement.infra,
 			restartCount: settlement.restartCount,
+			trace: settlement.trace,
+			settledAt,
 			seq
 		};
 	}
@@ -4056,7 +5620,7 @@ async function finalizeWait(child, settlement, seq, args, now, handle) {
 		runId: args.root,
 		target: "agent.child",
 		phase: "after",
-		timestamp: now(),
+		timestamp: settledAt,
 		stepIndex: seq,
 		parentId: args.parentId,
 		payload: {
@@ -4071,6 +5635,8 @@ async function finalizeWait(child, settlement, seq, args, now, handle) {
 		out: settlement.out,
 		outRef: settlement.outRef,
 		spent: settlement.spent,
+		trace: settlement.trace,
+		settledAt,
 		seq
 	};
 }
@@ -4085,54 +5651,101 @@ async function finalizeWait(child, settlement, seq, args, now, handle) {
 * applied per child). The reservation is reconciled on EVERY path (success, abort, throw)
 * so the conserved pool can never leak a reservation.
 */
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now) {
+async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now, executionReady, deadlineAtMs) {
 	let reconciled = false;
+	let started = false;
+	let terminalTelemetryCaptured = false;
+	let teardownStarted = false;
+	let traceEvidence;
+	const captureTraceOnce = async () => {
+		traceEvidence ??= await captureWorkerTraceEvidence(live.readTraceSource, blobs, started);
+		return traceEvidence;
+	};
+	const teardownOnce = async (grace) => {
+		if (teardownStarted) return;
+		teardownStarted = true;
+		await teardownExecutor(executor, grace, deadlineAtMs, now);
+		live.cleanupConfirmed = true;
+	};
 	const reconcileOnce = (spend) => {
-		if (reconciled) return;
+		if (reconciled) return void 0;
 		reconciled = true;
-		pool.reconcile(ticket, clampSpend(spend, opts.budget));
+		try {
+			pool.reconcile(ticket, spend);
+			return;
+		} catch (error) {
+			return error;
+		}
 	};
 	try {
+		await executionReady;
+		if (childAbort.signal.aborted) throw abortError(childAbort.signal);
 		live.status = "running";
+		started = true;
 		const ran = executor.execute(task, childAbort.signal);
 		let artifact;
 		if (isAsyncIterable(ran)) {
 			const spend = await foldStream(ran, (running) => {
 				live.spent = running;
 				live.lastActivityAt = now();
-			});
+			}, childAbort.signal);
 			live.spent = spend;
 			artifact = executor.resultArtifact();
-			reconcileOnce(spend);
+			const accounting = executor.accounting?.();
+			const terminalSpend = preserveUnknownTelemetry(spend, artifact.spent);
+			live.spent = accounting?.reported ?? terminalSpend;
+			terminalTelemetryCaptured = true;
+			live.executorDone = true;
+			const reconcileError = reconcileOnce(accounting?.reservation ?? terminalSpend);
+			if (reconcileError !== void 0) throw reconcileError;
 		} else {
-			const terminal = await ran;
-			live.spent = terminal.spent;
+			const terminal = await awaitAbortable(Promise.resolve(ran), childAbort.signal);
+			const accounting = executor.accounting?.();
+			live.spent = accounting?.reported ?? terminal.spent;
 			artifact = terminal;
-			reconcileOnce(terminal.spent);
+			terminalTelemetryCaptured = true;
+			live.executorDone = true;
+			const reconcileError = reconcileOnce(accounting?.reservation ?? terminal.spent);
+			if (reconcileError !== void 0) throw reconcileError;
 		}
 		live.executorDone = true;
 		const ownMetered = executor.metered?.();
+		const trace = await captureTraceOnce();
 		if (childAbort.signal.aborted) {
-			await teardownSafe(executor, opts.shutdown ?? "brutalKill");
-			return downRecord("aborted before settle", true, ownMetered);
+			await teardownOnce(opts.shutdown ?? "brutalKill");
+			return downRecord("aborted before settle", true, trace, ownMetered);
 		}
 		const outRef = contentAddress(artifact.out);
 		await blobs.put(outRef, artifact.out);
-		await teardownSafe(executor, opts.shutdown ?? "infinity");
+		await teardownOnce(opts.shutdown ?? 5e3);
 		return {
 			kind: "done",
 			out: artifact.out,
 			outRef,
 			...artifact.verdict ? { verdict: artifact.verdict } : {},
 			spent: live.spent,
+			trace,
 			...ownMetered ? { metered: ownMetered } : {}
 		};
 	} catch (err) {
 		live.executorDone = true;
-		reconcileOnce(live.spent);
-		await teardownSafe(executor, "brutalKill");
+		const trace = await captureTraceOnce();
+		let teardownError;
+		try {
+			await teardownOnce("brutalKill");
+		} catch (error) {
+			teardownError = error;
+		}
+		const accounting = executor.accounting?.();
+		if (accounting) live.spent = accounting.reported;
 		const aborted = childAbort.signal.aborted || isAbortError(err);
-		return downRecord(errMessage(err), aborted || isInfraError(err), executor.metered?.());
+		if (started && !terminalTelemetryCaptured && accounting === void 0) live.spent = {
+			...live.spent,
+			tokensKnown: false,
+			usdKnown: false
+		};
+		const reconcileError = reconcileOnce(accounting?.reservation ?? live.spent);
+		return downRecord(errMessage(err), teardownError !== void 0 || reconcileError !== void 0 || aborted || isInfraError(err), trace, executor.metered?.());
 	}
 }
 /**
@@ -4164,6 +5777,25 @@ function settledToIteration(settled) {
 		}
 	};
 }
+function normalizeLiveWorkerLimit(value) {
+	if (value === void 0 || value <= 0) return void 0;
+	if (!Number.isSafeInteger(value)) throw new ValidationError(`createScope: maxLiveWorkers must be a positive safe integer or <= 0 for uncapped, got ${String(value)}`);
+	return value;
+}
+function acquireLiveWorker(capacity) {
+	if (capacity.max !== void 0 && capacity.live >= capacity.max) return { ok: false };
+	capacity.live += 1;
+	let released = false;
+	return {
+		ok: true,
+		release() {
+			if (released) return;
+			released = true;
+			capacity.live -= 1;
+			if (capacity.live < 0) throw new ValidationError("scope: live-worker capacity released more than once");
+		}
+	};
+}
 function makeTreeView(root, children) {
 	const nodes = [...children.values()].map((c) => ({
 		id: c.id,
@@ -4172,8 +5804,15 @@ function makeTreeView(root, children) {
 		status: c.status,
 		runtime: c.runtime,
 		budget: c.budget,
+		...c.ownedTreeRoot === void 0 ? {} : { ownedTreeRoot: c.ownedTreeRoot },
+		...c.assignmentId === void 0 ? {} : { assignmentId: c.assignmentId },
+		...c.identity ? { identity: c.identity } : {},
+		...c.materialization ? { materialization: c.materialization } : {},
+		...c.executionBindings.length > 0 ? { executionBindings: Object.freeze([...c.executionBindings]) } : {},
 		spent: c.spent,
-		...c.outRef ? { outRef: c.outRef } : {}
+		...c.settledAt === void 0 ? {} : { settledAt: c.settledAt },
+		...c.outRef ? { outRef: c.outRef } : {},
+		...c.trace ? { trace: c.trace } : {}
 	}));
 	return {
 		root,
@@ -4187,9 +5826,49 @@ function frozenHandle(child) {
 		id: child.id,
 		label: child.label,
 		status: child.status,
+		...child.assignmentId === void 0 ? {} : { assignmentId: child.assignmentId },
+		...child.identity ? { identity: child.identity } : {},
+		...child.materialization ? { materialization: child.materialization } : {},
+		...child.executionBindings.length > 0 ? { executionBindings: Object.freeze([...child.executionBindings]) } : {},
 		abort() {}
 	};
 }
+/** Derive the portable identity of the exact profile and task a node will execute. Caller-owned
+* candidate/correlation fields are checked at this boundary before they enter the durable log. */
+function deriveNodeExecutionIdentity(spec, task) {
+	const digest = (value) => {
+		try {
+			return canonicalCandidateDigest(value);
+		} catch {
+			return;
+		}
+	};
+	const profileDigest = digest(spec.profile);
+	const taskDigest = digest(task);
+	const candidateDigest = spec.execution?.candidateDigest;
+	if (candidateDigest !== void 0 && !sha256DigestSchema.safeParse(candidateDigest).success) throw new ValidationError("scope.spawn: execution.candidateDigest must be a sha256 digest");
+	const correlation = freezeCorrelation(spec.execution?.correlation);
+	if (!profileDigest && !taskDigest && !candidateDigest && !correlation) return void 0;
+	return Object.freeze({
+		...profileDigest ? { profileDigest } : {},
+		...taskDigest ? { taskDigest } : {},
+		...candidateDigest ? { candidateDigest } : {},
+		...correlation ? { correlation } : {}
+	});
+}
+function isCompleteIdentity(identity) {
+	return identity?.profileDigest !== void 0 && identity.taskDigest !== void 0;
+}
+function sameNodeExecutionIdentity(a, b) {
+	return canonicalCandidateDigest(a) === canonicalCandidateDigest(b);
+}
+function freezeCorrelation(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ValidationError("scope.spawn: execution.correlation must be a string record");
+	const entries = Object.entries(value);
+	for (const [key, item] of entries) if (key.length === 0 || typeof item !== "string" || item.length === 0) throw new ValidationError("scope.spawn: execution.correlation keys and values must be non-empty strings");
+	return Object.freeze(Object.fromEntries(entries));
+}
 /**
 * Fold a streaming executor's normalized usage into the conserved `Spend`, publishing the
 * running total after EVERY event via `onProgress`.
@@ -4200,7 +5879,7 @@ function frozenHandle(child) {
 * turns deep from one that had produced nothing. It also means a worker that THROWS mid-stream
 * now reconciles its real partial spend instead of refunding work the provider already billed.
 */
-async function foldStream(stream, onProgress) {
+async function foldStream(stream, onProgress, signal) {
 	const tokens = {
 		input: 0,
 		output: 0
@@ -4208,21 +5887,30 @@ async function foldStream(stream, onProgress) {
 	let usd = 0;
 	let usdKnown = true;
 	let iterations = 0;
-	for await (const ev of stream) {
-		if (ev.kind === "tokens") {
-			tokens.input += ev.input;
-			tokens.output += ev.output;
-		} else if (ev.kind === "cost") {
-			usd += ev.usd;
-			if (ev.usdKnown === false) usdKnown = false;
-		} else iterations += 1;
-		onProgress?.({
-			iterations,
-			tokens: { ...tokens },
-			usd,
-			...usdKnown ? {} : { usdKnown: false },
-			ms: 0
-		});
+	const iterator = stream[Symbol.asyncIterator]();
+	try {
+		for (;;) {
+			const next = signal ? await awaitAbortable(Promise.resolve(iterator.next()), signal) : await iterator.next();
+			if (next.done) break;
+			const ev = next.value;
+			if (ev.kind === "tokens") {
+				tokens.input += ev.input;
+				tokens.output += ev.output;
+			} else if (ev.kind === "cost") {
+				usd += ev.usd;
+				if (ev.usdKnown === false) usdKnown = false;
+			} else iterations += 1;
+			onProgress?.({
+				iterations,
+				tokens: { ...tokens },
+				usd,
+				...usdKnown ? {} : { usdKnown: false },
+				ms: 0
+			});
+		}
+	} catch (error) {
+		Promise.resolve(iterator.return?.()).catch(() => void 0);
+		throw error;
 	}
 	return {
 		iterations,
@@ -4232,43 +5920,63 @@ async function foldStream(stream, onProgress) {
 		ms: 0
 	};
 }
-/** Clamp a child's reported spend to its reservation so the pool's fail-loud over-spend
-*  guard never trips on a benign overshoot from an external usage report; the difference
-*  refunds to the pool as if the child stopped at its ceiling. */
-function clampSpend(spend, budget) {
-	const totalTokens = spend.tokens.input + spend.tokens.output;
-	const tokensOk = totalTokens <= budget.maxTokens;
-	const itersOk = spend.iterations <= budget.maxIterations;
-	const usdOk = budget.maxUsd === void 0 || spend.usd <= budget.maxUsd;
-	if (tokensOk && itersOk && usdOk) return spend;
-	const ratio = !tokensOk && totalTokens > 0 ? budget.maxTokens / totalTokens : 1;
+/** Usage events carry measured increments; the terminal artifact carries whether a provider omitted
+* a whole accounting channel. Preserve those unknowns on the common streaming path. */
+function preserveUnknownTelemetry(streamed, terminal) {
 	return {
-		iterations: Math.min(spend.iterations, budget.maxIterations),
-		tokens: ratio < 1 ? {
-			input: Math.floor(spend.tokens.input * ratio),
-			output: Math.floor(spend.tokens.output * ratio)
-		} : spend.tokens,
-		usd: budget.maxUsd === void 0 ? spend.usd : Math.min(spend.usd, budget.maxUsd),
-		...spend.tokensKnown === false ? { tokensKnown: false } : {},
-		...spend.usdKnown === false ? { usdKnown: false } : {},
-		ms: spend.ms
-	};
-}
-async function teardownSafe(executor, grace) {
-	try {
-		await executor.teardown(grace);
-	} catch {}
+		...streamed,
+		...terminal.tokensKnown === false ? { tokensKnown: false } : {},
+		...terminal.usdKnown === false ? { usdKnown: false } : {},
+		ms: terminal.ms
+	};
 }
-function downRecord(reason, infra, metered) {
+async function awaitAbortable(work, signal) {
+	if (signal.aborted) {
+		work.catch(() => void 0);
+		throw abortError(signal);
+	}
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const onAbort = () => {
+			queueMicrotask(() => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(abortError(signal));
+			});
+		};
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		signal.addEventListener("abort", onAbort, { once: true });
+		work.then((value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function abortError(signal) {
+	const reason = signal.reason;
+	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "execution aborted");
+	error.name = "AbortError";
+	return error;
+}
+function downRecord(reason, infra, trace, metered) {
 	return {
 		kind: "down",
 		reason,
 		infra,
 		restartCount: 0,
+		trace,
 		...metered ? { metered } : {}
 	};
 }
-function zeroSpend() {
+function zeroSpend$1() {
 	return {
 		iterations: 0,
 		tokens: {
@@ -4289,6 +5997,20 @@ function isAgentSpec(value) {
 	const v = value;
 	return "profile" in v && "harness" in v;
 }
+/** Snapshot every data field whose bytes affect identity, admission, or materialization while
+* preserving the executable callbacks by reference. The executor implementation is trusted code;
+* its profile and attribution inputs are not. */
+function snapshotAgentSpec(raw) {
+	const { profile: rawProfile, harness, execution: rawExecution, ...runtimeExtensions } = raw;
+	const profile = detachedSnapshot(rawProfile, "scope.spawn profile");
+	const execution = rawExecution === void 0 ? void 0 : detachedSnapshot(rawExecution, "scope.spawn execution");
+	return Object.freeze({
+		...runtimeExtensions,
+		profile,
+		harness,
+		...execution === void 0 ? {} : { execution }
+	});
+}
 function isAbortError(err) {
 	return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
 }
@@ -4304,474 +6026,358 @@ function errMessage(err) {
 }
 //#endregion
 //#region src/runtime/supervise/driver-executor.ts
-/**
-*
-* The recursive driver-executor — the seam that lets a SPAWNED child be a DRIVER, so
-* agents drive agents drive agents over the one keystone atom.
-*
-* A spawned child resolves through the open registry to an `Executor`; the built-in
-* executors (router/inline, sandbox, cli) are LEAVES — `execute(task, signal)` runs the
-* work and settles. This executor is the recursive case: on `execute`, it mounts a NESTED
-* `Scope` (the scope hands it the mount via the `nested-scope` seam) over the SAME
-* conserved pool + shared journal/blobs + the same open registry, one `depth` deeper, then
-* runs the wrapped driver `Agent.act(task, nestedScope)`. The driver spawns its own
-* children into that nested scope; each resolves to EITHER a leaf executor (a worker child)
-* OR this same driver-executor (a driver child) — recursively. So a driver spawns a driver
-* spawns a worker, all on one budget-conserving tree.
-*
-* Why this preserves every keystone invariant (the scope owns the sharing; this executor
-* only runs the driver over what the scope mounts):
-*  - Conserved budget: the nested scope reserves from the SAME `BudgetPool` the root owns
-*    (the scope mounts it over `args.pool`), so `Σk` is conserved ACROSS depth by
-*    construction — a deep tree cannot overspend the root ceiling (reserve-on-spawn fails
-*    closed at any depth).
-*  - Journal: the nested scope writes to its OWN tree key (`${journalRoot}/${nodeId}`) so
-*    its cursor `seq`s never collide with the parent's in the per-tree uniqueness guard,
-*    while every nested tree shares the one `SpawnJournal` — the whole recursion is one
-*    journal, queryable tree by tree.
-*  - Settlement bubbling: the driver child settles into its PARENT scope with the conserved
-*    spend summed off its nested tree's settled events, so the parent's pool reconcile +
-*    the supervisor's `spentTotal` see the whole sub-tree's spend rolled up — settlements
-*    bubble to the root.
-*  - Depth ceiling: the nested scope runs at `depth+1`, so the supervisor's `maxDepth`
-*    (paired with the conserved pool per R3) fails a spawn closed once the recursion is too
-*    deep — exactly as it does for a flat tree.
-*
-* Layering: pure keystone composition. It reuses the scope's `NestedScopeSeam` + the shared
-* `SpawnJournal`; it builds NO new budget, journal, or selection logic. The recursion rides
-* the existing atom.
-*
-* @experimental
-*/
-/** The runtime tag the registry maps a driver child to. */
-const driverRuntime = "driver";
 /** The metadata marker on a driver child's spec the recursive registry routes on. */
 const driverRole = "driver";
-/** True when a spec is a driver child (carries the role marker + a driver Agent). */
-function isDriverSpec(spec) {
-	if (spec.profile.metadata?.role !== driverRole) return false;
-	const driver = spec.driver;
-	if (!isAgent(driver)) throw new ValidationError("driverExecutor: a driver-role spec must carry a `driver` Agent to run inside its nested scope");
-	return true;
-}
-/**
-* The recursive driver-executor factory. `withDriverExecutor` routes a child marked
-* `role: 'driver'` here; any other child resolves to a leaf built-in. On `execute`, it
-* reads the `nested-scope` seam the SCOPE seeded, mounts a nested `Scope` one `depth`
-* deeper over the shared pool/journal/blobs/registry, runs the driver
-* `Agent.act(task, nestedScope)`, and reports the conserved spend summed off the nested
-* tree's settled events — so the parent scope's reconcile rolls the whole sub-tree's spend
-* into the conserved total.
-*
-* A `down` from the nested driver (a thrown `act` or an aborted scope) propagates as a
-* thrown executor, which the parent scope types into a `down` settlement — the same
-* fail-loud-into-typed-down discipline a leaf gets.
-*/
-const driverExecutorFactory = (spec, ctx) => {
-	if (!isDriverSpec(spec)) throw new ValidationError("driverExecutorFactory: spec is not a driver child (no role:\"driver\" marker)");
-	const driver = spec.driver;
-	const journal = spec.journal;
-	const seam = readNestedScopeSeam(ctx);
-	let artifact;
-	let meteredSpend;
-	return {
-		runtime: driverRuntime,
-		async execute(task, signal) {
-			const nestedRoot = nestedTreeKey(seam, journal);
-			await journal.beginTree(nestedRoot, (/* @__PURE__ */ new Date(0)).toISOString());
-			const nestedScope = seam.mount(nestedRoot, signal);
-			try {
-				const out = await driver.act(task, nestedScope);
-				const events = await loadTreeEvents(journal, nestedRoot);
-				const settled = events.filter(isSettled);
-				meteredSpend = nonZeroOrUndef(sumMetered(events));
-				const verdict = deriveDeliveryVerdict(settled);
-				artifact = {
-					outRef: `${driverRuntime}:${nestedRoot}`,
-					out,
-					spent: sumSpend(settled),
-					...verdict ? { verdict } : {}
-				};
-				return artifact;
-			} catch (err) {
-				meteredSpend = await safeSumMetered(journal, nestedRoot);
-				throw err;
-			}
-		},
-		metered() {
-			return meteredSpend;
-		},
-		teardown() {
-			return Promise.resolve({ destroyed: true });
-		},
-		resultArtifact() {
-			if (!artifact) throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
-			return artifact;
-		}
-	};
-};
 /**
-* Register the driver-executor so a child marked `role: 'driver'` resolves to it. The base
-* registry resolves by harness alone (it does not read `role`), so a recursive run needs a
-* registry that routes the driver tag here FIRST. Returns a registry decorator: a
-* driver-role spec → the driver-executor; everything else → the base registry's resolution
-* (leaf built-ins + BYO).
+* Mark + carry a driver `Agent` so the recursive registry resolves it to the
+* driver-executor. The returned agent is SPAWNED (never run directly): its
+* `executorSpec` is marked `role: 'driver'` and carries the driver agent + the shared
+* journal so the executor can run its `act` inside a nested scope. `act` fails loud if
+* called directly — a driver child runs THROUGH its nested-scope executor, never as a root.
 */
-function withDriverExecutor(base) {
-	return {
-		register: base.register.bind(base),
-		resolve(spec) {
-			if (spec.profile.metadata?.role === driverRole && !spec.executor) return {
-				succeeded: true,
-				value: driverExecutorFactory
-			};
-			return base.resolve(spec);
-		}
-	};
-}
-/** Mint a unique nested-tree key under the parent's journal root. Uses the parent's
-*  `journalRoot` + a per-journal monotonic ordinal so two sibling driver trees never
-*  collide their keys (each driver child mints exactly one nested tree). */
-function nestedTreeKey(seam, journal) {
-	return `${seam.journalRoot}/d${nextNestOrdinal(journal)}`;
-}
-/** Per-journal monotonic nest counter — keyed on the journal instance so a single run's
-*  nested-tree keys are unique without a shared module global. */
-const nestCounters = /* @__PURE__ */ new WeakMap();
-function nextNestOrdinal(journal) {
-	let c = nestCounters.get(journal);
-	if (!c) {
-		c = { n: 0 };
-		nestCounters.set(journal, c);
-	}
-	return c.n++;
-}
-/** The nested tree's full event list — the one evidence the spend, verdict, AND driver-inference
-*  roll-ups read off the same journal the supervisor sums. */
-async function loadTreeEvents(journal, nestedRoot) {
-	const events = await journal.loadTree(nestedRoot);
-	if (events === void 0) throw new ValidationError(`driverExecutor: nested tree '${nestedRoot}' missing from the journal after run (corrupted log)`);
-	return events;
-}
-function isSettled(ev) {
-	return ev.kind === "settled";
-}
-/** Sum the conserved spend over the nested tree's settled events — the honest per-channel
-*  roll-up of the whole sub-tree's child WORK. */
-function sumSpend(settled) {
-	const total = {
-		iterations: 0,
-		tokens: {
-			input: 0,
-			output: 0
-		},
-		usd: 0,
-		ms: 0
-	};
-	for (const ev of settled) {
-		total.iterations += ev.spent.iterations;
-		total.tokens.input += ev.spent.tokens.input;
-		total.tokens.output += ev.spent.tokens.output;
-		total.usd += ev.spent.usd;
-		if (ev.spent.tokensKnown === false) total.tokensKnown = false;
-		if (ev.spent.usdKnown === false) total.usdKnown = false;
-		total.ms += ev.spent.ms;
-	}
-	return total;
-}
-/** Sum the nested tree's `metered` events — the sub-tree's whole driver INFERENCE (this driver's
-*  own turns + any sub-driver inference already re-homed into this tree). Re-homed up to the parent
-*  as one `metered` event; never reconciled (already pool-debited live via `observe`). */
-function sumMetered(events) {
-	const total = {
-		iterations: 0,
-		tokens: {
-			input: 0,
-			output: 0
-		},
-		usd: 0,
-		ms: 0
-	};
-	for (const ev of events) {
-		if (ev.kind !== "metered") continue;
-		total.iterations += ev.spend.iterations;
-		total.tokens.input += ev.spend.tokens.input;
-		total.tokens.output += ev.spend.tokens.output;
-		total.usd += ev.spend.usd;
-		if (ev.spend.tokensKnown === false) total.tokensKnown = false;
-		if (ev.spend.usdKnown === false) total.usdKnown = false;
-		total.ms += ev.spend.ms;
-	}
-	return total;
-}
-/** An all-zero spend that carries an UNKNOWN marker counts as non-zero: a sub-driver whose turns
-*  went unmeasured did real work, and dropping its `metered` event here would re-hide upstream the
-*  very turn the driver refused to skip. */
-function isNonZeroSpend(s) {
-	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
-}
-/** A spend, or `undefined` when it is all-zero — so `metered()` returns undefined for a driver
-*  whose sub-tree did no inference (and the parent journals no empty `metered` event). */
-function nonZeroOrUndef(s) {
-	return isNonZeroSpend(s) ? s : void 0;
-}
-/** Sum the nested tree's metered events, tolerating a missing tree (a crash before `beginTree`
-*  landed) — never throw here, or it would mask the original `act` error on the crash path. */
-async function safeSumMetered(journal, nestedRoot) {
-	try {
-		return nonZeroOrUndef(sumMetered(await loadTreeEvents(journal, nestedRoot)));
-	} catch {
-		return;
-	}
-}
-/** Derive the driver child's delivery verdict from its DIRECT children's settlements:
-*  `valid` iff any direct child settled `done` AND `valid` (the keep-best finalize's pick);
-*  `score` = the best delivered score. Returns `undefined` when no child settled at all (the
-*  driver itself produced nothing to bubble a verdict from). Fail-closed: a child whose verdict
-*  carried no `valid` counts as not-delivered. */
-function deriveDeliveryVerdict(settled) {
-	let sawChild = false;
-	let anyValid = false;
-	let bestValidScore;
-	let bestDoneScore;
-	for (const ev of settled) {
-		sawChild = true;
-		if (ev.status !== "done") continue;
-		const score = ev.verdict?.score;
-		if (score !== void 0 && (bestDoneScore === void 0 || score > bestDoneScore)) bestDoneScore = score;
-		if (ev.verdict?.valid === true) {
-			anyValid = true;
-			if (score !== void 0 && (bestValidScore === void 0 || score > bestValidScore)) bestValidScore = score;
-		}
-	}
-	if (!sawChild) return void 0;
+function driverChild(profileOrName, driver, journal, execution) {
+	const profile = typeof profileOrName === "string" ? {
+		name: profileOrName,
+		metadata: { role: driverRole }
+	} : profileOrName;
+	const name = profile.name ?? driver.name;
+	const spec = {
+		profile,
+		harness: null,
+		...execution ? { execution } : {},
+		driverRuntime,
+		driver,
+		journal
+	};
+	const deliver = driver.deliver?.bind(driver);
 	return {
-		valid: anyValid,
-		score: anyValid ? bestValidScore ?? 1 : bestDoneScore ?? 0
+		name,
+		executorSpec: spec,
+		...deliver ? { deliver(message) {
+			return deliver(message) !== false;
+		} } : {},
+		act() {
+			throw new ValidationError(`driverChild: "${name}" was run directly; a driver child runs through its nested-scope executor`);
+		}
 	};
 }
-function readNestedScopeSeam(ctx) {
-	const seam = ctx.seams[nestedScopeSeamKey];
-	if (!seam || typeof seam.mount !== "function") throw new ValidationError(`driverExecutor: missing required seam "${nestedScopeSeamKey}" — a driver child must be spawned through a Scope that seeds it (the keystone scope does)`);
-	return seam;
-}
-function isAgent(value) {
-	return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
+/** True when a spec is a driver child (carries the role marker + a driver Agent). */
+function isDriverSpec(spec) {
+	if (spec.driverRuntime !== "driver") return false;
+	const driver = spec.driver;
+	if (!isAgent(driver)) throw new ValidationError("driverExecutor: a driver-role spec must carry a `driver` Agent to run inside its nested scope");
+	return true;
 }
-//#endregion
-//#region src/runtime/supervise/budget.ts
 /**
+* The recursive driver-executor factory. `withDriverExecutor` routes a child marked
+* `role: 'driver'` here; any other child resolves to a leaf built-in. On `execute`, it
+* reads the `nested-scope` seam the SCOPE seeded, mounts a nested `Scope` one `depth`
+* deeper over the driver's reserved child pool plus shared journal/blobs/registry, runs the driver
+* `Agent.act(task, nestedScope)`, and reports the conserved spend summed off the nested
+* tree's settled events — so the parent scope's reconcile rolls the whole sub-tree's spend
+* into the conserved total.
 *
-* The conserved budget reservation pool — the invariant the whole instrument
-* rests on (critique M5/B3). One root `Budget` becomes a conserved pool of three
-* quantities (tokens, usd, iterations) plus an absolute deadline. Children reserve
-* atomically at spawn and reconcile at settle:
-*
-*   total ≡ free + reserved + committed          (for every known quantity)
-*
-* `reserve` moves a child's whole ceiling from `free` → `reserved` and fails closed
-* when `free` can't cover it (never read-then-spawn overcommit, so `Σk(treatment) ≡
-* Σk(blind)` by construction). `reconcile` releases the reservation, commits ACTUAL
-* spend, and refunds the unspent remainder to `free`. Tokens and usd are separate
-* channels (`LoopTokenUsage` has no `usd`); iterations are conserved alongside them.
-*
-* Pure and deterministic: `now()` is injected, there is no I/O, and no wall-clock or
-* RNG read. A `reserve`/`reconcile` ticket is single-use (fail-loud on double or
-* unknown reconcile) so a child can never refund twice. Reconciling an OPEN ticket always
-* closes it: a fail-loud condition settles the reservation first and throws afterwards, so no
-* error path can strand a reservation past the join barrier's `assertNoOpenTickets`.
-* A child that declared no `maxUsd` reserved no dollar allocation, so its real dollars are
-* committed as observed spend and debited from the root's balance rather than treated as an
-* overspend of a $0 ceiling it never asked for. If dollar cost is unknowable under a
-* dollar limit, reconciliation closes the known token/iteration work, marks the dollar channel
-* unusable, and refuses later reservations; inventing a numeric dollar total would be worse.
-* If a TOKEN count is unknowable (a provider that reported no usage for work that ran), the pool
-* records the work, debits what it knows, and marks `readout().tokensKnown` false — the balance is
-* then a ceiling, not a measurement. It does not close admission the way the dollar channel does:
-* tokens are always capped, so one unreported turn must not end the run.
-*
-* @experimental
+* A `down` from the nested driver (a thrown `act` or an aborted scope) propagates as a
+* thrown executor, which the parent scope types into a `down` settlement — the same
+* fail-loud-into-typed-down discipline a leaf gets.
 */
-/** Fold a normalized `UsageEvent` array into a `Spend`. Tokens and usd are separate
-*  channels; iterations come from `'iteration'` events. Pure; `ms` stays zero (the
-*  pool does not read wall-clock). */
-function spendFromUsageEvents(events) {
-	const tokens = zeroTokenUsage();
-	let usd = 0;
-	let usdKnown = true;
-	let iterations = 0;
-	for (const ev of events) if (ev.kind === "tokens") addTokenUsage(tokens, {
-		input: ev.input,
-		output: ev.output
-	});
-	else if (ev.kind === "cost") {
-		usd += ev.usd;
-		if (ev.usdKnown === false) usdKnown = false;
-	} else iterations += 1;
-	return {
-		iterations,
-		tokens,
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		ms: 0
+const driverExecutorFactory = (spec, ctx) => {
+	if (!isDriverSpec(spec)) throw new ValidationError("driverExecutorFactory: spec is not a driver child (no role:\"driver\" marker)");
+	const driver = spec.driver;
+	const deliver = driver.deliver?.bind(driver);
+	const journal = spec.journal;
+	const seam = readNestedScopeSeam(ctx);
+	let artifact;
+	let meteredSpend;
+	let accounting;
+	let active;
+	const closeActive = (reason) => {
+		if (active === void 0) return Promise.resolve();
+		active.close ??= closeNestedScope(active.scope, active.controller, reason);
+		return active.close;
 	};
-}
-async function foldUsage(events) {
-	if (Array.isArray(events)) return spendFromUsageEvents(events);
-	const tokens = zeroTokenUsage();
-	let usd = 0;
-	let usdKnown = true;
-	let iterations = 0;
-	for await (const ev of events) if (ev.kind === "tokens") addTokenUsage(tokens, {
-		input: ev.input,
-		output: ev.output
+	const treeOwner = attestNestedDriverTreeOwner({
+		runtime: driverRuntime,
+		...deliver ? { deliver(message) {
+			return deliver(message) !== false;
+		} } : {},
+		async execute(task, signal) {
+			const nestedRoot = nestedDriverTreeRoot(seam.journalRoot, seam.nodeId);
+			await journal.beginTree(nestedRoot, (/* @__PURE__ */ new Date(0)).toISOString());
+			const controller = new AbortController();
+			const onParentAbort = () => controller.abort(signal.reason);
+			if (signal.aborted) controller.abort(signal.reason);
+			else signal.addEventListener("abort", onParentAbort, { once: true });
+			const nestedScope = seam.mount(nestedRoot, controller.signal);
+			active = {
+				controller,
+				scope: nestedScope
+			};
+			try {
+				const out = await driverActAbortable(() => driver.act(task, nestedScope), controller.signal);
+				await finalizeScopeOwnerMaterialization(nestedScope);
+				await closeActive("driver completed");
+				const events = await loadTreeEvents(journal, nestedRoot);
+				const settled = events.filter(isSettled);
+				const childWork = sumSpend(settled);
+				meteredSpend = nonZeroOrUndef(sumMetered(events));
+				accounting = {
+					reported: childWork,
+					reservation: addSpend$1(childWork, meteredSpend ?? zeroSpend())
+				};
+				const verdict = deriveDeliveryVerdict(settled, out);
+				artifact = {
+					outRef: `${driverRuntime}:${nestedRoot}`,
+					out,
+					spent: childWork,
+					...verdict ? { verdict } : {}
+				};
+				return artifact;
+			} catch (err) {
+				await finalizeScopeOwnerMaterialization(active?.scope ?? nestedScope).catch(() => void 0);
+				await closeActive("driver stopped");
+				const partial = await safeRollup(journal, nestedRoot);
+				meteredSpend = partial?.metered;
+				accounting = partial?.accounting;
+				throw err;
+			} finally {
+				signal.removeEventListener("abort", onParentAbort);
+				active = void 0;
+			}
+		},
+		accounting() {
+			return accounting;
+		},
+		metered() {
+			return meteredSpend;
+		},
+		async teardown() {
+			await closeActive("driver executor teardown");
+			return { destroyed: true };
+		},
+		resultArtifact() {
+			if (!artifact) throw new ValidationError("driverExecutor: resultArtifact() read before execute()");
+			return artifact;
+		}
 	});
-	else if (ev.kind === "cost") {
-		usd += ev.usd;
-		if (ev.usdKnown === false) usdKnown = false;
-	} else iterations += 1;
+	const ownerRuntime = runtimeOwnedScopeOwnerRuntime(driver);
+	return ownerRuntime === void 0 ? treeOwner : attestRuntimeOwnedDeferredExecutor(treeOwner, ownerRuntime);
+};
+/**
+* Register the driver-executor so a child marked `role: 'driver'` resolves to it. The base
+* registry resolves by harness alone (it does not read `role`), so a recursive run needs a
+* registry that routes the driver tag here FIRST. Returns a registry decorator: a
+* driver-role spec → the driver-executor; everything else → the base registry's resolution
+* (leaf built-ins + BYO).
+*/
+function withDriverExecutor(base) {
 	return {
-		iterations,
-		tokens,
-		usd,
-		...usdKnown ? {} : { usdKnown: false },
-		ms: 0
+		register: base.register.bind(base),
+		resolve(spec) {
+			if (spec.driverRuntime === "driver" && !spec.executor) return {
+				succeeded: true,
+				value: driverExecutorFactory
+			};
+			return base.resolve(spec);
+		}
 	};
 }
-function totalTokens(usage) {
-	return usage.input + usage.output;
+async function closeNestedScope(scope, controller, reason) {
+	if (!controller.signal.aborted) controller.abort(reason);
+	for (;;) if (await scope.next() === null) break;
+	const view = scope.view;
+	if (view.inFlight > 0 || view.waiting > 0) throw new ValidationError(`driverExecutor: nested cleanup left ${view.inFlight} running and ${view.waiting} waiting nodes`);
 }
-/**
-* Create a conserved reservation pool from a root `Budget`. `now()` is injected so the
-* deadline readout is deterministic; defaults to `Date.now` for non-test callers. The
-* absolute deadline is fixed at construction (`now() + budget.deadlineMs`) so the
-* readout's `deadlineMs` is a stable wall-clock instant, not a shrinking remainder.
-*/
-function createBudgetPool(root, now = Date.now) {
-	let freeTokens = root.maxTokens;
-	let reservedTokens = 0;
-	let committedTokens = 0;
-	let tokensTainted = false;
-	const usdCapped = root.maxUsd !== void 0;
-	let freeUsd = root.maxUsd ?? 0;
-	let reservedUsd = 0;
-	let committedUsd = 0;
-	let usdTainted = false;
-	let freeIterations = root.maxIterations;
-	let reservedIterations = 0;
-	let committedIterations = 0;
-	const absoluteDeadlineMs = root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0;
-	let nextTicketId = 0;
-	const open = /* @__PURE__ */ new Set();
-	function reserve(b) {
-		const wantTokens = b.maxTokens;
-		const wantUsd = b.maxUsd ?? 0;
-		const wantIterations = b.maxIterations;
-		if (usdCapped && usdTainted) return {
-			ok: false,
-			reason: "budget-exhausted"
-		};
-		if (wantTokens > freeTokens) return {
-			ok: false,
-			reason: "budget-exhausted"
-		};
-		if (wantIterations > freeIterations) return {
-			ok: false,
-			reason: "budget-exhausted"
-		};
-		if (wantUsd > 0 && !usdCapped) return {
-			ok: false,
-			reason: "usd-unbudgeted"
-		};
-		if (wantUsd > freeUsd) return {
-			ok: false,
-			reason: "budget-exhausted"
+async function driverActAbortable(act, signal) {
+	if (signal.aborted) throw driverAbortError(signal);
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			queueMicrotask(() => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(driverAbortError(signal));
+			});
 		};
-		freeTokens -= wantTokens;
-		reservedTokens += wantTokens;
-		freeIterations -= wantIterations;
-		reservedIterations += wantIterations;
-		if (wantUsd > 0) {
-			freeUsd -= wantUsd;
-			reservedUsd += wantUsd;
+		signal.addEventListener("abort", onAbort, { once: true });
+		let work;
+		try {
+			work = Promise.resolve(act());
+		} catch (error) {
+			cleanup();
+			reject(error);
+			return;
 		}
-		const id = nextTicketId++;
-		open.add(id);
-		return {
-			ok: true,
-			ticket: {
-				id,
-				reserved: {
-					tokens: wantTokens,
-					usd: wantUsd,
-					iterations: wantIterations,
-					usdBudgeted: b.maxUsd !== void 0
-				}
-			}
-		};
-	}
-	function reconcile(ticket, spent) {
-		if (!open.has(ticket.id)) throw new Error(`budget pool: reconcile of unknown or already-settled ticket ${ticket.id}`);
-		const { tokens: rTokens, usd: rUsd, iterations: rIterations } = ticket.reserved;
-		const unknownUnderCap = usdCapped && spent.usdKnown === false;
-		const spentTokens = totalTokens(spent.tokens);
-		const usdBudgeted = ticket.reserved.usdBudgeted !== false;
-		let violation;
-		if (spentTokens > rTokens) violation = `ticket ${ticket.id} spent ${spentTokens} tokens > reserved ${rTokens}`;
-		else if (spent.iterations > rIterations) violation = `ticket ${ticket.id} spent ${spent.iterations} iterations > reserved ${rIterations}`;
-		else if (usdCapped && usdBudgeted && spent.usd > rUsd) violation = `ticket ${ticket.id} spent $${spent.usd} > reserved $${rUsd}`;
-		else if (unknownUnderCap) violation = `ticket ${ticket.id} reported unknown dollar cost under a dollar-capped budget`;
-		open.delete(ticket.id);
-		if (spent.tokensKnown === false) tokensTainted = true;
-		reservedTokens -= rTokens;
-		committedTokens += spentTokens;
-		freeTokens += rTokens - spentTokens;
-		reservedIterations -= rIterations;
-		committedIterations += spent.iterations;
-		freeIterations += rIterations - spent.iterations;
-		if (usdCapped) {
-			reservedUsd -= rUsd;
-			committedUsd += spent.usd;
-			if (unknownUnderCap) {
-				usdTainted = true;
-				freeUsd = 0;
-			} else freeUsd += rUsd - spent.usd;
-		} else committedUsd += spent.usd;
-		if (violation !== void 0) throw new Error(`budget pool: ${violation}`);
+		work.then((value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function driverAbortError(signal) {
+	const reason = signal.reason;
+	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "driver aborted");
+	error.name = "AbortError";
+	return error;
+}
+/** The nested tree's full event list — the one evidence the spend, verdict, AND driver-inference
+*  roll-ups read off the same journal the supervisor sums. */
+async function loadTreeEvents(journal, nestedRoot) {
+	const events = await journal.loadTree(nestedRoot);
+	if (events === void 0) throw new ValidationError(`driverExecutor: nested tree '${nestedRoot}' missing from the journal after run (corrupted log)`);
+	return events;
+}
+function isSettled(ev) {
+	return ev.kind === "settled";
+}
+/** Sum the conserved spend over the nested tree's settled events — the honest per-channel
+*  roll-up of the whole sub-tree's child WORK. */
+function sumSpend(settled) {
+	const total = {
+		iterations: 0,
+		tokens: {
+			input: 0,
+			output: 0
+		},
+		usd: 0,
+		ms: 0
+	};
+	for (const ev of settled) {
+		total.iterations += ev.spent.iterations;
+		total.tokens.input += ev.spent.tokens.input;
+		total.tokens.output += ev.spent.tokens.output;
+		if (ev.spent.tokensKnown === false) total.tokensKnown = false;
+		total.usd += ev.spent.usd;
+		if (ev.spent.tokensKnown === false) total.tokensKnown = false;
+		if (ev.spent.usdKnown === false) total.usdKnown = false;
+		total.ms += ev.spent.ms;
 	}
-	function observe(spend) {
-		if (usdCapped && spend.usdKnown === false) throw new Error("budget pool: cannot observe unknown dollar cost under a dollar-capped budget");
-		if (spend.tokensKnown === false) tokensTainted = true;
-		const tokens = totalTokens(spend.tokens);
-		freeTokens -= tokens;
-		committedTokens += tokens;
-		freeIterations -= spend.iterations;
-		committedIterations += spend.iterations;
-		committedUsd += spend.usd;
-		if (usdCapped) freeUsd -= spend.usd;
+	return total;
+}
+/** Sum the nested tree's `metered` events — the sub-tree's whole driver INFERENCE (this driver's
+*  own turns + any sub-driver inference already re-homed into this tree). Re-homed up to the parent
+*  as one `metered` event; never reconciled (already pool-debited live via `observe`). */
+function sumMetered(events) {
+	const total = {
+		iterations: 0,
+		tokens: {
+			input: 0,
+			output: 0
+		},
+		usd: 0,
+		ms: 0
+	};
+	for (const ev of events) {
+		if (ev.kind !== "metered") continue;
+		total.iterations += ev.spend.iterations;
+		total.tokens.input += ev.spend.tokens.input;
+		total.tokens.output += ev.spend.tokens.output;
+		if (ev.spend.tokensKnown === false) total.tokensKnown = false;
+		total.usd += ev.spend.usd;
+		if (ev.spend.tokensKnown === false) total.tokensKnown = false;
+		if (ev.spend.usdKnown === false) total.usdKnown = false;
+		total.ms += ev.spend.ms;
 	}
-	function readout() {
+	return total;
+}
+function zeroSpend() {
+	return {
+		iterations: 0,
+		tokens: {
+			input: 0,
+			output: 0
+		},
+		usd: 0,
+		ms: 0
+	};
+}
+function addSpend$1(a, b) {
+	return {
+		iterations: a.iterations + b.iterations,
+		tokens: {
+			input: a.tokens.input + b.tokens.input,
+			output: a.tokens.output + b.tokens.output
+		},
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: a.usd + b.usd,
+		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
+		ms: a.ms + b.ms
+	};
+}
+/** An all-zero spend that carries an UNKNOWN marker counts as non-zero: a sub-driver whose turns
+*  went unmeasured did real work, and dropping its `metered` event here would re-hide upstream the
+*  very turn the driver refused to skip. */
+function isNonZeroSpend(s) {
+	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
+}
+/** A spend, or `undefined` when it is all-zero — so `metered()` returns undefined for a driver
+*  whose sub-tree did no inference (and the parent journals no empty `metered` event). */
+function nonZeroOrUndef(s) {
+	return isNonZeroSpend(s) ? s : void 0;
+}
+/** Sum the nested tree's metered events, tolerating a missing tree (a crash before `beginTree`
+*  landed) — never throw here, or it would mask the original `act` error on the crash path. */
+async function safeRollup(journal, nestedRoot) {
+	try {
+		const events = await loadTreeEvents(journal, nestedRoot);
+		const childWork = sumSpend(events.filter(isSettled));
+		const metered = nonZeroOrUndef(sumMetered(events));
 		return {
-			tokensLeft: freeTokens,
-			tokensKnown: !tokensTainted,
-			usdLeft: usdCapped ? usdTainted ? 0 : freeUsd : 0,
-			usdCapped,
-			deadlineMs: absoluteDeadlineMs,
-			reservedTokens
+			metered,
+			accounting: {
+				reported: childWork,
+				reservation: addSpend$1(childWork, metered ?? zeroSpend())
+			}
 		};
+	} catch {
+		return;
 	}
-	function assertNoOpenTickets() {
-		if (open.size > 0) throw new Error(`budget pool: ${open.size} reservation(s) still open at join barrier (leaked ticket ids: ${[...open].join(", ")}) — conserved-pool invariant violated`);
+}
+/** Derive the driver child's delivery verdict from its DIRECT children's settlements and the
+*  manager's actual finalized output: `valid` iff a direct child delivered AND the finalizer
+*  returned a defined output;
+*  `score` = the best delivered score. Returns `undefined` when no child settled at all (the
+*  driver itself produced nothing to bubble a verdict from). Fail-closed: a child whose verdict
+*  carried no `valid` counts as not-delivered. */
+function deriveDeliveryVerdict(settled, finalizedOutput) {
+	let sawChild = false;
+	let anyValid = false;
+	let bestValidScore;
+	let bestDoneScore;
+	for (const ev of settled) {
+		sawChild = true;
+		if (ev.status !== "done") continue;
+		const score = ev.verdict?.score;
+		if (score !== void 0 && (bestDoneScore === void 0 || score > bestDoneScore)) bestDoneScore = score;
+		if (ev.verdict?.valid === true) {
+			anyValid = true;
+			if (score !== void 0 && (bestValidScore === void 0 || score > bestValidScore)) bestValidScore = score;
+		}
 	}
+	if (!sawChild) return void 0;
+	const accepted = anyValid && finalizedOutput !== void 0;
 	return {
-		reserve,
-		reconcile,
-		spendFrom: foldUsage,
-		readout,
-		observe,
-		assertNoOpenTickets
+		valid: accepted,
+		score: accepted ? bestValidScore ?? 1 : bestDoneScore ?? 0
 	};
 }
+function readNestedScopeSeam(ctx) {
+	const seam = ctx.seams[nestedScopeSeamKey];
+	if (!seam || typeof seam.mount !== "function") throw new ValidationError(`driverExecutor: missing required seam "${nestedScopeSeamKey}" — a driver child must be spawned through a Scope that seeds it (the keystone scope does)`);
+	return seam;
+}
+function isAgent(value) {
+	return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
+}
 //#endregion
 //#region src/runtime/supervise/finalizer.ts
 /**
@@ -4923,20 +6529,99 @@ function keyedAssignments(events, settled) {
 	const spawns = events.filter((ev) => ev.kind === "spawned").sort((a, b) => a.seq - b.seq);
 	for (const ev of spawns) {
 		if (ev.key === void 0) continue;
+		if (ev.identity === void 0) throw new RuntimeRunStateError(`supervisor: keyed node '${ev.id}' has no durable execution identity`);
 		const s = byId.get(ev.id);
 		keys.set(ev.key, s === void 0 ? {
 			id: ev.id,
 			label: ev.label,
+			identity: ev.identity,
 			state: "in-doubt"
 		} : {
 			id: ev.id,
 			label: ev.label,
+			identity: ev.identity,
 			state: s.kind === "done" ? "completed" : "down",
 			settled: s
 		});
 	}
 	return keys;
 }
+/** A resumed process may continue only the exact root contract first recorded for this run id. */
+function assertResumeContract(events, opts) {
+	const roots = events.filter((event) => event.kind === "spawned" && event.id === opts.runId && event.parent === void 0);
+	if (roots.length !== 1) throw new RuntimeRunStateError(`supervisor: resumed run '${opts.runId}' must contain exactly one root identity event; found ${roots.length}`);
+	const recorded = roots[0];
+	if (contentAddress(recorded.budget) !== contentAddress(opts.budget)) throw new RuntimeRunStateError(`supervisor: resume budget mismatch for run '${opts.runId}'; use a new runId to change limits`);
+	if (!sameOptionalIdentity(recorded.identity, opts.rootIdentity)) throw new RuntimeRunStateError(`supervisor: resume identity mismatch for run '${opts.runId}'; task, profile, candidate, and correlation must match`);
+	const receipts = events.filter((event) => event.kind === "materialized" && event.id === opts.runId);
+	const expectedReceipt = rootMaterializationReceipt(opts);
+	if (expectedReceipt === void 0) {
+		if (receipts.length > 1) throw new RuntimeRunStateError(`supervisor: resumed run '${opts.runId}' contains duplicate root materialization evidence`);
+	} else if (receipts.length !== 1 || contentAddress(receipts[0]?.receipt) !== contentAddress(expectedReceipt)) throw new RuntimeRunStateError(`supervisor: resume materialization mismatch for run '${opts.runId}'; backend, model, execution identity, and plan must match`);
+	return recorded;
+}
+/** Mint root evidence at the trusted composition boundary. A generic in-process Agent root has no
+* executor declaration and remains explicitly unknown rather than inheriting fabricated details. */
+function rootMaterializationReceipt(opts) {
+	const declaration = opts.rootMaterialization;
+	if (declaration === void 0) return unknownMaterializationReceipt({
+		...opts.rootIdentity?.profileDigest === void 0 ? {} : { authoredProfileDigest: opts.rootIdentity.profileDigest },
+		runtime: "inline",
+		reason: "root-agent-did-not-report"
+	});
+	if (declaration.declaration === "deferred") return void 0;
+	if (opts.rootIdentity?.profileDigest === void 0) throw new RuntimeRunStateError(`supervisor: run '${opts.runId}' cannot record known root materialization without an exact profileDigest`);
+	try {
+		return knownMaterializationReceipt({
+			authoredProfileDigest: opts.rootIdentity.profileDigest,
+			runtime: declaration.runtime,
+			declaration: declaration.declaration
+		});
+	} catch (error) {
+		throw new RuntimeRunStateError(`supervisor: run '${opts.runId}' has invalid root materialization evidence`, { cause: error });
+	}
+}
+function rootExecutionBindingReceipt(opts, materialization, attemptId) {
+	const root = opts.rootMaterialization;
+	if (root?.declaration === "deferred") return void 0;
+	if (root === void 0) return unknownExecutionBindingReceipt(materialization, attemptId, "root-agent-did-not-report");
+	try {
+		return knownExecutionBindingReceipt(materialization, {
+			attemptId,
+			...root.binding
+		});
+	} catch (error) {
+		throw new RuntimeRunStateError(`supervisor: run '${opts.runId}' has invalid root execution binding`, { cause: error });
+	}
+}
+function sameOptionalIdentity(recorded, requested) {
+	if (recorded === void 0 || requested === void 0) return recorded === requested;
+	return contentAddress(recorded) === contentAddress(requested);
+}
+/** Validate caller-supplied root identity before any journal access. Fresh runs may omit identity,
+* but once supplied it is trusted durable evidence and therefore must be complete and canonical;
+* resumed runs always require it so the prior root can be matched exactly. */
+function assertRootIdentity(opts) {
+	const identity = opts.rootIdentity;
+	if (identity === void 0) {
+		if (opts.resume !== true) return;
+		throw new RuntimeRunStateError(`supervisor: resumed run '${opts.runId}' requires an exact rootIdentity with profileDigest and taskDigest`);
+	}
+	const unknownFields = Object.keys(identity).filter((key) => key !== "profileDigest" && key !== "taskDigest" && key !== "candidateDigest" && key !== "correlation");
+	const correlation = identity.correlation;
+	const validCorrelation = correlation === void 0 || typeof correlation === "object" && correlation !== null && !Array.isArray(correlation) && Object.entries(correlation).every(([key, value]) => key.length > 0 && typeof value === "string" && value.length > 0);
+	if (unknownFields.length > 0 || !sha256DigestSchema.safeParse(identity.profileDigest).success || !sha256DigestSchema.safeParse(identity.taskDigest).success || identity.candidateDigest !== void 0 && !sha256DigestSchema.safeParse(identity.candidateDigest).success || !validCorrelation) throw new RuntimeRunStateError(`supervisor: run '${opts.runId}' requires an exact rootIdentity with valid profileDigest, taskDigest, candidateDigest, and correlation`);
+}
+function rootDeadline(root) {
+	const startedAt = Date.parse(root.at);
+	if (!Number.isFinite(startedAt)) throw new RuntimeRunStateError(`supervisor: root event for '${root.id}' has an invalid timestamp '${root.at}'`);
+	return startedAt + (root.budget.deadlineMs ?? 0);
+}
+/** Child reservations whose spawn was durable but whose terminal record never landed. */
+function uncertainSpawnBudgets(events) {
+	const terminal = new Set(events.filter((event) => event.kind === "settled" || event.kind === "cancelled" || event.kind === "woken").map((event) => event.id));
+	return events.filter((event) => event.kind === "spawned" && event.parent !== void 0 && !terminal.has(event.id)).map((event) => event.budget);
+}
 /** Highest `seq` among events matching `pred`, or `-1` when none match (so a resumed scope's
 *  first new ordinal/seq is 0 — the same start a fresh scope uses). */
 function maxSeqOf(events, pred) {
@@ -4974,129 +6659,239 @@ function describeRejection(error) {
 function createSupervisor() {
 	let attached;
 	async function run(root, task, opts) {
-		const now = opts.now ?? Date.now;
-		const pool = createBudgetPool(opts.budget, now);
-		const prior = opts.resume === true ? await opts.journal.loadTree(opts.runId) : void 0;
-		const resuming = prior !== void 0 && prior.length > 0;
-		let resumeFrom;
-		if (resuming) {
-			const settled = await replaySpawnTree(opts.journal, opts.blobs, opts.runId);
-			resumeFrom = {
-				settled,
-				view: materializeTreeView(prior),
-				maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
-				maxCursorSeq: maxSeqOf(prior, (ev) => ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken"),
-				maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
-				waits: pendingWaits(prior),
-				keys: keyedAssignments(prior, settled),
-				priorSpend: sumSpendFromEvents(prior)
-			};
-		} else {
-			await opts.journal.beginTree(opts.runId, new Date(now()).toISOString());
-			await opts.journal.appendEvent(opts.runId, {
-				kind: "spawned",
-				id: opts.runId,
-				label: "root",
-				budget: opts.budget,
-				runtime: "inline",
-				seq: 0,
-				at: new Date(now()).toISOString()
-			});
-		}
-		const controller = new AbortController();
-		const cascadeAbort = (reason) => {
-			if (controller.signal.aborted) return;
-			controller.abort(reason);
-		};
-		const onCallerAbort = () => cascadeAbort("caller signal aborted");
-		if (opts.signal) if (opts.signal.aborted) cascadeAbort("caller signal aborted");
-		else opts.signal.addEventListener("abort", onCallerAbort, { once: true });
-		const breaker = createIntensityBreaker(opts, () => cascadeAbort("intensity breaker tripped"));
-		const journal = wrapJournalForBreaker(opts.journal, breaker);
-		const scope = createScope({
-			parentId: opts.runId,
-			root: opts.runId,
-			pool,
-			journal,
-			blobs: opts.blobs,
-			executors: opts.executors,
-			seams: {},
-			depth: 0,
-			maxDepth: opts.maxDepth ?? defaultMaxDepth,
-			signal: controller.signal,
-			now,
-			hooks: opts.hooks,
-			...opts.probes ? { probes: opts.probes } : {},
-			...opts.workerTrace ? { workerTrace: opts.workerTrace } : {},
-			...resumeFrom ? { resumeFrom } : {}
-		});
-		const openScope = scope;
-		if (attached) attached.bind({
-			scope: openScope,
-			cascadeAbort,
-			signal: pushRootSignal(cascadeAbort)
+		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, resume, now: suppliedNow, signal, hooks, workerTrace } = opts;
+		const input = detachedSnapshot({
+			task,
+			options: {
+				budget,
+				runId,
+				...rootIdentity === void 0 ? {} : { rootIdentity },
+				...rootMaterialization === void 0 ? {} : { rootMaterialization },
+				...maxDepth === void 0 ? {} : { maxDepth },
+				...maxLiveWorkers === void 0 ? {} : { maxLiveWorkers },
+				...maxRestarts === void 0 ? {} : { maxRestarts },
+				...withinMs === void 0 ? {} : { withinMs },
+				...resume === void 0 ? {} : { resume }
+			}
+		}, "supervisor.run");
+		opts = Object.freeze({
+			...input.options,
+			journal: journalStore,
+			blobs: blobStore,
+			executors: executorRegistry,
+			...probes === void 0 ? {} : { probes },
+			...suppliedNow === void 0 ? {} : { now: suppliedNow },
+			...signal === void 0 ? {} : { signal },
+			...hooks === void 0 ? {} : { hooks },
+			...workerTrace === void 0 ? {} : { workerTrace }
 		});
-		let actOutcome;
+		task = input.task;
+		const rootAct = root.act.bind(root);
+		const rootDeliver = root.deliver?.bind(root);
+		const now = opts.now ?? Date.now;
+		assertRootIdentity(opts);
+		const rootLease = attached?.acquire();
 		try {
-			actOutcome = {
-				ok: true,
-				out: await root.act(task, scope)
+			const rootAttemptId = newExecutionAttemptId(opts.runId);
+			const runStartedAtMs = now();
+			const runStartedAt = new Date(runStartedAtMs).toISOString();
+			const existing = await opts.journal.loadTree(opts.runId);
+			if (opts.resume !== true && existing !== void 0) throw new RuntimeRunStateError(`supervisor: runId '${opts.runId}' already exists; pass resume: true to continue it or use a new runId`);
+			const prior = opts.resume === true ? existing : void 0;
+			const resuming = prior !== void 0 && prior.length > 0;
+			let resumeFrom;
+			let pool;
+			if (resuming) {
+				const rootEvent = assertResumeContract(prior, opts);
+				const measured = sumMeasuredSpendFromEvents(prior);
+				const uncertainReservations = uncertainSpawnBudgets(prior);
+				pool = createBudgetPool(opts.budget, now, {
+					committed: addSpend(measured.childWork, measured.driverInference),
+					uncertainReservations,
+					...rootEvent.budget.deadlineMs !== void 0 ? { absoluteDeadlineMs: rootDeadline(rootEvent) } : {}
+				});
+				const settled = await replaySpawnTree(opts.journal, opts.blobs, opts.runId);
+				resumeFrom = {
+					settled,
+					view: materializeTreeView(prior),
+					maxSpawnOrdinal: maxSeqOf(prior, (ev) => ev.kind === "spawned"),
+					maxCursorSeq: maxSeqOf(prior, (ev) => ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken"),
+					maxWaitOrdinal: maxSeqOf(prior, (ev) => ev.kind === "waiting"),
+					waits: pendingWaits(prior),
+					keys: keyedAssignments(prior, settled),
+					priorSpend: sumSpendFromEvents(prior)
+				};
+			} else {
+				pool = createBudgetPool(opts.budget, now, { ...opts.budget.deadlineMs !== void 0 ? { absoluteDeadlineMs: runStartedAtMs + opts.budget.deadlineMs } : {} });
+				await opts.journal.beginTree(opts.runId, runStartedAt);
+				const rootReceipt = rootMaterializationReceipt(opts);
+				const rootRuntime = opts.rootMaterialization?.runtime ?? "inline";
+				await opts.journal.appendEvent(opts.runId, {
+					kind: "spawned",
+					id: opts.runId,
+					label: "root",
+					budget: opts.budget,
+					runtime: rootRuntime,
+					...opts.rootIdentity ? { identity: opts.rootIdentity } : {},
+					seq: 0,
+					at: runStartedAt
+				});
+				if (rootReceipt !== void 0) await opts.journal.appendEvent(opts.runId, {
+					kind: "materialized",
+					id: opts.runId,
+					receipt: rootReceipt,
+					seq: 0,
+					at: runStartedAt
+				});
+			}
+			const stableRootReceipt = resuming ? prior?.find((event) => event.kind === "materialized" && event.id === opts.runId)?.receipt : rootMaterializationReceipt(opts);
+			if (stableRootReceipt !== void 0) {
+				const rootBinding = rootExecutionBindingReceipt(opts, stableRootReceipt, rootAttemptId);
+				if (rootBinding !== void 0) await opts.journal.appendEvent(opts.runId, {
+					kind: "execution-bound",
+					id: opts.runId,
+					binding: rootBinding,
+					seq: 0,
+					at: runStartedAt
+				});
+			}
+			const controller = new AbortController();
+			const cascadeAbort = (reason) => {
+				if (controller.signal.aborted) return false;
+				controller.abort(reason);
+				return true;
 			};
-		} catch (error) {
-			actOutcome = {
+			const onCallerAbort = () => cascadeAbort("caller signal aborted");
+			if (opts.signal) if (opts.signal.aborted) cascadeAbort("caller signal aborted");
+			else opts.signal.addEventListener("abort", onCallerAbort, { once: true });
+			const breaker = createIntensityBreaker(opts, () => cascadeAbort("intensity breaker tripped"));
+			const journal = wrapJournalForBreaker(opts.journal, breaker);
+			const priorRootMaterialization = prior?.find((event) => event.kind === "materialized" && event.id === opts.runId)?.receipt;
+			const scope = createScope({
+				parentId: opts.runId,
+				root: opts.runId,
+				pool,
+				journal,
+				blobs: opts.blobs,
+				executors: opts.executors,
+				seams: {},
+				depth: 0,
+				maxDepth: opts.maxDepth ?? defaultMaxDepth,
+				...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
+				signal: controller.signal,
+				now,
+				hooks: opts.hooks,
+				...opts.rootMaterialization?.declaration === "deferred" ? { ownerMaterialization: {
+					runtime: opts.rootMaterialization.runtime,
+					authoredProfile: opts.rootMaterialization.authoredProfile,
+					attemptId: rootAttemptId,
+					requiredKnown: true,
+					...priorRootMaterialization === void 0 ? {} : { prior: priorRootMaterialization }
+				} } : {},
+				...opts.probes ? { probes: opts.probes } : {},
+				...opts.workerTrace ? { workerTrace: opts.workerTrace } : {},
+				...resumeFrom ? { resumeFrom } : {}
+			});
+			const openScope = scope;
+			if (rootLease) rootLease.bind({
+				scope: openScope,
+				cascadeAbort,
+				signal: pushRootSignal(cascadeAbort),
+				deliver: rootDeliver ? (message) => rootDeliver(message) !== false : () => false
+			});
+			let deadlineExceeded = false;
+			const rootDeadlineAtMs = pool.readout().deadlineMs;
+			if (rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = cascadeAbort("root budget deadline exceeded");
+			const clearRootDeadline = opts.budget.deadlineMs === void 0 ? void 0 : armDeadlineTimer(Math.max(0, rootDeadlineAtMs - now()), () => {
+				deadlineExceeded = cascadeAbort("root budget deadline exceeded");
+			});
+			let actOutcome = {
 				ok: false,
-				error
+				error: new RuntimeRunStateError("supervisor: root execution did not start")
 			};
-		} finally {
-			await drainLiveChildren(openScope, controller);
-			if (opts.signal) opts.signal.removeEventListener("abort", onCallerAbort);
-			if (attached) attached.unbind();
-		}
-		const tree = runTree(scope);
-		if (actOutcome.ok) {
+			let executionAborted = controller.signal.aborted;
+			try {
+				actOutcome = {
+					ok: true,
+					out: await runAbortable(() => rootAct(task, scope), controller.signal)
+				};
+			} catch (error) {
+				actOutcome = {
+					ok: false,
+					error
+				};
+			} finally {
+				executionAborted = controller.signal.aborted;
+				if (!controller.signal.aborted && rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = true;
+				clearRootDeadline?.();
+				try {
+					await drainLiveChildren(openScope, controller);
+				} catch (error) {
+					if (actOutcome?.ok !== false) actOutcome = {
+						ok: false,
+						error
+					};
+				}
+				try {
+					await finalizeScopeOwnerMaterialization(openScope);
+				} catch (error) {
+					if (actOutcome?.ok !== false) actOutcome = {
+						ok: false,
+						error
+					};
+				}
+				if (opts.signal) opts.signal.removeEventListener("abort", onCallerAbort);
+				rootLease?.release();
+			}
+			const tree = runTree(scope);
 			pool.assertNoOpenTickets();
-			const out = actOutcome.out;
-			if (out !== void 0) {
-				const outRef = contentAddress(out);
-				await opts.blobs.put(outRef, out);
+			if (actOutcome.ok) {
+				if (executionAborted) return noWinner();
+				const out = actOutcome.out;
+				if (out !== void 0) {
+					const outRef = contentAddress(out);
+					await opts.blobs.put(outRef, out);
+					const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
+					return {
+						kind: "winner",
+						out,
+						outRef,
+						tree,
+						spentTotal: addSpend(childWork, driverInference),
+						...isNonEmptySpend(driverInference) ? { spentBreakdown: {
+							driverInference,
+							childWork
+						} } : {}
+					};
+				}
+				return noWinner();
+			}
+			return noWinner({ error: actOutcome.error });
+			async function noWinner(rejection) {
 				const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
-				return {
-					kind: "winner",
-					out,
-					outRef,
+				const common = {
+					kind: "no-winner",
 					tree,
-					spentTotal: addSpend(childWork, driverInference),
-					...isNonEmptySpend(driverInference) ? { spentBreakdown: {
-						driverInference,
-						childWork
-					} } : {}
+					downCount: breaker.downCount(),
+					spentTotal: addSpend(childWork, driverInference)
+				};
+				const lifecycle = classifyNoWinner(controller, pool, opts, breaker, deadlineExceeded, tree);
+				if (lifecycle !== void 0) return {
+					...common,
+					reason: lifecycle
+				};
+				if (rejection !== void 0) return {
+					...common,
+					reason: "driver-failed",
+					error: describeRejection(rejection.error)
+				};
+				return {
+					...common,
+					reason: "all-children-down"
 				};
 			}
-			return noWinner();
-		}
-		return noWinner({ error: actOutcome.error });
-		async function noWinner(rejection) {
-			const { childWork, driverInference } = await spentFromJournal(journal, opts.runId);
-			const common = {
-				kind: "no-winner",
-				tree,
-				downCount: breaker.downCount(),
-				spentTotal: addSpend(childWork, driverInference)
-			};
-			const lifecycle = classifyNoWinner(controller, pool, opts, breaker);
-			if (lifecycle !== void 0) return {
-				...common,
-				reason: lifecycle
-			};
-			if (rejection !== void 0) return {
-				...common,
-				reason: "driver-failed",
-				error: describeRejection(rejection.error)
-			};
-			return {
-				...common,
-				reason: "all-children-down"
-			};
+		} finally {
+			rootLease?.release();
 		}
 	}
 	function attach(h) {
@@ -5113,6 +6908,56 @@ function createSupervisor() {
 *  can prove a handle is ours and reach its binding without leaking the control onto the
 *  frozen `RootHandle` shape. */
 const rootControls = /* @__PURE__ */ new WeakMap();
+/**
+* Mint a `RootHandle` plus its supervisor-private control. The handle is the substrate a
+* chat/pi-viz client attaches to (Q2): `view()` reads the live tree, `signal()` delivers
+* an out-of-band message, `abort()` cascades. Before `run` binds it (and after `run`
+* unbinds it) the handle is fail-loud: a client that talks to a handle that is not
+* driving a live run gets a typed error, never a silent no-op.
+*/
+function createRootHandle() {
+	let binding;
+	let activeLease;
+	const handle = {
+		view() {
+			if (!binding) throw new RuntimeRunStateError("RootHandle.view: handle is not bound to a live run (attach it before run, read after run starts)");
+			return binding.scope.view;
+		},
+		deliver(msg) {
+			if (!binding) throw new RuntimeRunStateError("RootHandle.deliver: handle is not bound to a live run");
+			return binding.deliver(msg);
+		},
+		signal(msg) {
+			if (!binding) throw new RuntimeRunStateError("RootHandle.signal: handle is not bound to a live run");
+			binding.signal(msg);
+		},
+		abort(reason) {
+			if (!binding) throw new RuntimeRunStateError("RootHandle.abort: handle is not bound to a live run");
+			binding.cascadeAbort(reason ?? "root handle aborted");
+		}
+	};
+	rootControls.set(handle, { acquire() {
+		if (activeLease !== void 0) throw new RuntimeRunStateError("RootHandle: handle already controls a live run; use one handle per concurrent run");
+		const token = Symbol("root-handle-lease");
+		activeLease = token;
+		let released = false;
+		return {
+			bind(next) {
+				if (released || activeLease !== token) throw new RuntimeRunStateError("RootHandle: live-run lease is no longer active");
+				if (binding !== void 0) throw new RuntimeRunStateError("RootHandle: live-run lease is already bound");
+				binding = next;
+			},
+			release() {
+				if (released) return;
+				released = true;
+				if (activeLease !== token) return;
+				binding = void 0;
+				activeLease = void 0;
+			}
+		};
+	} });
+	return handle;
+}
 /** A `RootSignal` sink: `cancel` cascades an abort; pause/resume/ask are observability
 *  signals the substrate accepts but does not act on here (the chat/pi-viz client owns
 *  pause semantics — building them now would be mechanism ahead of the gate). */
@@ -5172,27 +7017,82 @@ function wrapJournalForBreaker(journal, breaker) {
 */
 async function drainLiveChildren(scope, controller) {
 	const view = scope.view;
-	if (!(view.inFlight > 0 || view.waiting > 0)) return;
+	if (!(view.inFlight > 0 || view.waiting > 0)) {
+		if (scope.workerCapacity.live > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${scope.workerCapacity.live} executor resource(s) not confirmed destroyed`);
+		return;
+	}
 	if (!controller.signal.aborted) controller.abort();
-	await Promise.allSettled([drainCursor(scope)]);
+	await drainCursor(scope);
+	const after = scope.view;
+	if (after.inFlight > 0 || after.waiting > 0 || scope.workerCapacity.live > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running, ${after.waiting} waiting, and ${scope.workerCapacity.live} executor resource(s) not confirmed destroyed`);
 }
 async function drainCursor(scope) {
 	for (;;) if (await scope.next() === null) return;
 }
+/** Race root policy execution against the same signal that stops every child. The losing promise
+* remains observed, so a late rejection cannot surface as an unhandled process error. */
+async function runAbortable(act, signal) {
+	if (signal.aborted) throw supervisorAbortError(signal);
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			queueMicrotask(() => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(supervisorAbortError(signal));
+			});
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		let work;
+		try {
+			work = Promise.resolve(act());
+		} catch (error) {
+			cleanup();
+			reject(error);
+			return;
+		}
+		work.then((value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		});
+	});
+}
+function supervisorAbortError(signal) {
+	const reason = signal.reason;
+	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "supervisor aborted");
+	error.name = "AbortError";
+	return error;
+}
 /**
 * The lifecycle cause of a no-winner, or `undefined` when the supervisor's own state proves
 * nothing. Returning `undefined` rather than falling through to `all-children-down` is what lets
 * the caller decide between the `driver-failed` arm (a rejection was captured) and the residual
 * bucket — and it is why `driver-failed` cannot be produced without an `error` to attach.
 */
-function classifyNoWinner(controller, pool, opts, breaker) {
+function classifyNoWinner(controller, pool, opts, breaker, deadlineExceeded, tree) {
 	if (breaker.tripped()) return "all-children-down";
+	if (deadlineExceeded) return "budget-exhausted";
 	if (controller.signal.aborted) return "aborted";
+	if (allSpawnedChildrenDown(tree)) return "all-children-down";
 	if (poolExhausted(pool, opts)) return "budget-exhausted";
 	if (breaker.downCount() > 0) return "all-children-down";
 }
+function allSpawnedChildrenDown(tree) {
+	const children = tree.nodes.filter((node) => node.id !== tree.root);
+	return children.length > 0 && children.every((node) => node.status === "failed");
+}
 function poolExhausted(pool, opts) {
 	const r = pool.readout();
+	if (r.iterationsLeft <= 0) return true;
 	if (r.tokensLeft <= 0) return true;
 	if (opts.budget.maxUsd !== void 0 && r.usdLeft <= 0) return true;
 	if (opts.budget.deadlineMs !== void 0 && r.deadlineMs > 0 && (opts.now ?? Date.now)() >= r.deadlineMs) return true;
@@ -5214,6 +7114,21 @@ async function spentFromJournal(journal, root) {
 *  `metered` = driver inference (re-homed up the tree, so a single root-tree pass already
 *  includes every nested driver's inference). */
 function sumSpendFromEvents(events) {
+	const totals = sumMeasuredSpendFromEvents(events);
+	const rootBudget = events.find((event) => event.kind === "spawned" && event.parent === void 0)?.budget;
+	let remainingRootUsd = Math.max(0, (rootBudget?.maxUsd ?? 0) - totals.childWork.usd - totals.driverInference.usd);
+	for (const budget of uncertainSpawnBudgets(events)) {
+		totals.childWork.iterations += budget.maxIterations;
+		totals.childWork.tokens.input += budget.maxTokens;
+		totals.childWork.tokensKnown = false;
+		const usdCharge = budget.maxUsd ?? (rootBudget?.maxUsd !== void 0 ? remainingRootUsd : 0);
+		totals.childWork.usd += usdCharge;
+		totals.childWork.usdKnown = false;
+		remainingRootUsd = Math.max(0, remainingRootUsd - usdCharge);
+	}
+	return totals;
+}
+function sumMeasuredSpendFromEvents(events) {
 	const childWork = {
 		iterations: 0,
 		tokens: {
@@ -5244,8 +7159,8 @@ function accumulate(a, b) {
 	a.iterations += b.iterations;
 	a.tokens.input += b.tokens.input;
 	a.tokens.output += b.tokens.output;
-	a.usd += b.usd;
 	if (b.tokensKnown === false) a.tokensKnown = false;
+	a.usd += b.usd;
 	if (b.usdKnown === false) a.usdKnown = false;
 	a.ms += b.ms;
 }
@@ -5258,21 +7173,19 @@ function addSpend(a, b) {
 			input: a.tokens.input + b.tokens.input,
 			output: a.tokens.output + b.tokens.output
 		},
-		usd: a.usd + b.usd,
 		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: a.usd + b.usd,
 		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
 		ms: a.ms + b.ms
 	};
 }
 /** True when any driver metered inference this run (so the winner carries a `spentBreakdown`).
 *  Checks every channel `addSpend` sums — including `ms` — so the gate stays consistent with the
-*  total even though the coordination driver currently stamps `ms: 0`. An all-zero spend that
-*  carries an UNKNOWN marker is non-empty: work happened and went unmeasured, which is exactly the
-*  fact a breakdown must not hide by looking like no work at all. */
+*  total even though the coordination driver currently stamps `ms: 0`. */
 function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { removeWorktree as $, sanitizeAgentRuntimeEvent as A, createActivityLog as B, exportEvalRuns as C, toOtelAttributes as D, loopEventToOtelSpan as E, pollFor as F, routerToolLoop as G, routerBrain as H, timerAt as I, runSettledCommand as J, streamRouterChatWithTools as K, validateWaitSpec as L, sanitizeRuntimeStreamEvent as M, createWaitProbes as N, createRuntimeEventCollector as O, isWaitOutcome as P, createWorktree as Q, waitUntil as R, createOtelExporter as S, generateSpanId as T, routerChatWithTools as U, readWorkerProgress as V, routerChatWithUsage as W, runWorktreeHarness as X, runWorktreeChecks as Y, captureWorktreeDiff as Z, traceContextToEnv as _, runFinalizer as a, buildLoopSpanNodes as b, spendFromUsageEvents as c, settledToIteration as d, harnessInvocation as et, readWorkerTraceContext as f, readTraceContextFromEnv as g, createPropagatingTraceEmitter as h, pickBestDelivered as i, sanitizeKnowledgeReadinessReport as j, createRuntimeStreamEventCollector as k, withDriverExecutor as l, workerTraceSeamKey as m, bestDelivered as n, runLocalHarness as nt, runTree as o, workerTraceEnv as p, runBrainLoop as q, collectDelivered as r, CodexExecutionDiagnosticError as rt, createBudgetPool as s, createSupervisor as t, parseCodexTokenUsage as tt, createScope as u, INTELLIGENCE_WIRE_VERSION as v, flatOtelSpan as w, buildRuntimeEventOtelSpans as x, buildLoopOtelSpans as y, DEFAULT_STALL_AFTER_MS as z };
+export { WORKER_TOKEN_FLOOR as $, loopEventToOtelSpan as A, promptControlProfileMaterialization as At, timerAt as B, harnessInvocation as Bt, buildLoopSpanNodes as C, removeWorktree as Ct, exportEvalRuns as D, defineProfileMaterializationContract as Dt, createOtelExporter as E, controlProfileMaterialization as Et, sanitizeKnowledgeReadinessReport as F, sandboxActProfileMaterialization as Ft, describeToolArgs as G, CodexExecutionDiagnosticError as Gt, waitUntil as H, localHarnessExecutable as Ht, sanitizeRuntimeStreamEvent as I, validateProfileMaterialization as It, freeSlots as J, readWorkerProgress as K, createWaitProbes as L, worktreeCliProfileMaterialization as Lt, createRuntimeEventCollector as M, promptOnlyProfileMaterialization as Mt, createRuntimeStreamEventCollector as N, promptResourceProfileMaterialization as Nt, flatOtelSpan as O, fullProfileMaterialization as Ot, sanitizeAgentRuntimeEvent as P, renderProfileMaterializationIssues as Pt, teardownExecutor as Q, isWaitOutcome as R, DEFAULT_LOCAL_HARNESS as Rt, buildLoopOtelSpans as S, createWorktree as St, createOpenInferenceFileExporter as T, assertProfileMaterialization as Tt, DEFAULT_STALL_AFTER_MS as U, parseCodexTokenUsage as Ut, validateWaitSpec as V, harnessSupportsReasoningEffort as Vt, createActivityLog as W, runLocalHarness as Wt, rollingDispatch as X, queueOf as Y, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Z, workerTraceSeamKey as _, runSettledCommand as _t, pickBestDelivered as a, attestRuntimeOwnedScopeOwner as at, traceContextToEnv as b, worktreeProfileExecutionPlan as bt, driverChild as c, runtimeOwnedExecutorExecutionBinding as ct, deriveNodeExecutionIdentity as d, routerBrain as dt, workerTokenFloor as et, recordScopeOwnerMaterialization as f, routerChatWithTools as ft, workerTraceEnv as g, runBrainLoop as gt, readWorkerTraceContext as h, streamRouterChatWithTools as ht, collectDelivered as i, attestRuntimeOwnedExecutor as it, toOtelAttributes as j, promptModelProfileMaterialization as jt, generateSpanId as k, profileMaterializationAxes as kt, withDriverExecutor as l, runtimeOwnedExecutorMaterialization as lt, settledToIteration as m, routerToolLoop as mt, createSupervisor as n, createBudgetPool as nt, runFinalizer as o, inheritRuntimeOwnedExecutorAttestation as ot, scopeOwnerExecutorNodeContext as p, routerChatWithUsage as pt, effectiveConcurrency as q, bestDelivered as r, spendFromUsageEvents as rt, runTree as s, newExecutionAttemptId as st, createRootHandle as t, assertValidBudget as tt, createScope as u, runtimeOwnedScopeOwnerRuntime as ut, createPropagatingTraceEmitter as v, runWorktreeChecks as vt, buildRuntimeEventOtelSpans as w, AGENT_PROFILE_MATERIALIZATION_AXES as wt, INTELLIGENCE_WIRE_VERSION as x, captureWorktreeDiff as xt, readTraceContextFromEnv as y, runWorktreeHarness as yt, pollFor as z, LOCAL_HARNESSES as zt };
 
-//# sourceMappingURL=supervisor-BBbPBXpe.js.map
+//# sourceMappingURL=supervisor-CpT9yAxL.js.map