@tangle-network/agent-runtime 0.116.0 → 0.117.0

package/dist/{supervise-BUR9ByF7.js → supervise-U7_K5yuV.js}

@@ -1,18 +1,18 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
+import { S as detachedSnapshot, b as workerTraceAnalysisStore, d as writeAllBytes, i as InMemorySpawnJournal, l as parseCommittedJsonLines, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as prepareJsonlAppend, x as contentAddress } from "./spawn-journal-B_mu_oH2.js";
 import { a as mapWithConcurrency, c as sleep, d as throwIfAborted, f as withTimeout, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage, r as deleteBoxSafe, s as randomUuid, t as abortError, u as throwAbort } from "./util-Cc9g9Y-o.js";
-import { a as contentAddress, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore } from "./spawn-journal-DCPbicXB.js";
-import { $ as removeWorktree, B as createActivityLog, D as toOtelAttributes, H as routerBrain, Q as createWorktree, S as createOtelExporter, T as generateSpanId, W as routerChatWithUsage, X as runWorktreeHarness, Y as runWorktreeChecks, Z as captureWorktreeDiff, a as runFinalizer, b as buildLoopSpanNodes, i as pickBestDelivered, l as withDriverExecutor, m as workerTraceSeamKey, n as bestDelivered, o as runTree, p as workerTraceEnv, q as runBrainLoop, t as createSupervisor } from "./supervisor-BBbPBXpe.js";
+import { C as buildLoopSpanNodes, Ct as controlProfileMaterialization, Dt as promptControlProfileMaterialization, E as createOtelExporter, Et as profileMaterializationAxes, Ot as promptModelProfileMaterialization, Pt as worktreeCliProfileMaterialization, Q as assertValidBudget, St as assertProfileMaterialization, Tt as fullProfileMaterialization, W as createActivityLog, X as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Z as teardownExecutor, _t as worktreeProfileExecutionPlan, a as pickBestDelivered, at as runtimeOwnedExecutorExecutionBinding, bt as removeWorktree, c as driverChild, ct as routerBrain, d as deriveNodeExecutionIdentity, et as spendFromUsageEvents, f as recordScopeOwnerMaterialization, g as workerTraceEnv, gt as runWorktreeHarness, ht as runWorktreeChecks, it as newExecutionAttemptId, j as toOtelAttributes, k as generateSpanId, l as withDriverExecutor, n as createSupervisor, nt as attestRuntimeOwnedScopeOwner, o as runFinalizer, ot as runtimeOwnedExecutorMaterialization, p as scopeOwnerExecutorNodeContext, pt as runBrainLoop, q as freeSlots, r as bestDelivered, rt as inheritRuntimeOwnedExecutorAttestation, s as runTree, st as runtimeOwnedScopeOwnerRuntime, tt as attestRuntimeOwnedExecutor, ut as routerChatWithUsage, vt as captureWorktreeDiff, wt as defineProfileMaterializationContract, yt as createWorktree } from "./supervisor-CAXiCKnX.js";
 import { i as notifyRuntimeHookEvent, t as composeRuntimeHooks } from "./runtime-hooks-C7iJOWm3.js";
-import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-DeI5xX8P.js";
-import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, s as buildBackendOptions } from "./environment-provider-CCaEhA-l.js";
+import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-Yhd1GYWl.js";
+import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, r as providerAsSandboxClient, s as buildBackendOptions } from "./environment-provider-CzcEyRL7.js";
 import { t as createStdioToolServer } from "./tool-server-RcWgLIsL.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
 import { argHash, computeFindingId, errorStreakDetector, estimateCost, isModelPriced, makeFinding, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
-import { agentProfileSchema } from "@tangle-network/agent-interface";
+import { agentProfileSchema, canonicalCandidateDigest, mergeAgentProfiles, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import path, { dirname, isAbsolute, join, sep } from "node:path";
+import path, { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
 import { createServer, request } from "node:http";
@@ -20,6 +20,28 @@ import { request as request$1 } from "node:https";
 import { Readable, Writable } from "node:stream";
 //#region src/runtime/supervise/completion-gate.ts
 /**
+*
+* The completion-oracle: **settled ⟺ DELIVERED.**
+*
+* Foreman's one hard lesson (0/18 self-improvement deliverables) — "done" must mean a check
+* PASSED, not the agent's say-so. `gateOnDeliverable` wraps an `Executor` so its settlement
+* is `valid` ONLY when the deliverable check passes. The child still RUNS and settles (its
+* spend is conserved into the pool either way), but a child that ran WITHOUT delivering
+* settles `valid:false` — so a keep-best driver never counts it as done, and a gate never
+* inflates with self-judged wins.
+*
+* Dual-purpose by construction:
+*  - product: the agent fleet only advances on real, checked deliverables.
+*  - proof: the gate's `valid` is the honest settle — equal-k comparisons can't be gamed by an
+*    arm that "ran" without producing the artifact.
+*
+* The check is a DEPLOYABLE oracle — a test command, a state verifier, the commit0 judge —
+* read off the child's output, never the model judging itself. A throwing check is
+* fail-closed (not delivered), never a crash.
+*
+* @experimental
+*/
+/**
 * Wrap an `Executor` so its settlement `valid` reflects the deliverable check, not the
 * inner verdict. Handles both `execute` shapes (one-shot `Promise<ExecutorResult>` and
 * streaming `AsyncIterable<UsageEvent>` + `resultArtifact()`); the check runs once the inner
@@ -39,7 +61,22 @@ function gateOnDeliverable(inner, deliverable) {
 			score: baseScore ?? (delivered ? 1 : 0)
 		};
 	};
-	return {
+	/**
+	* Ask the delivery question once, from whatever the inner executor managed to produce.
+	*
+	* Fail-closed on the artifact being unavailable: an executor that never produced one delivered
+	* nothing, and leaving `gated` unset keeps the existing invalid-by-default reading.
+	*/
+	const settleVerdict = async () => {
+		let art;
+		try {
+			art = inner.resultArtifact();
+		} catch {
+			return;
+		}
+		gated = await check(art.out, art.verdict?.score);
+	};
+	return inheritRuntimeOwnedExecutorAttestation(inner, {
 		runtime: inner.runtime,
 		...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
 		...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
@@ -48,13 +85,21 @@ function gateOnDeliverable(inner, deliverable) {
 		...inner.metered ? { metered: () => inner.metered?.() } : {},
 		execute(task, signal) {
 			const r = inner.execute(task, signal);
-			if (isAsyncIterable$1(r)) return (async function* () {
-				for await (const ev of r) yield ev;
-				const art = inner.resultArtifact();
-				gated = await check(art.out, art.verdict?.score);
+			if (isAsyncIterable$2(r)) return (async function* () {
+				try {
+					for await (const ev of r) yield ev;
+				} finally {
+					await settleVerdict();
+				}
 			})();
 			return (async () => {
-				const res = await r;
+				let res;
+				try {
+					res = await r;
+				} catch (error) {
+					await settleVerdict();
+					throw error;
+				}
 				gated = await check(res.out, res.verdict?.score);
 				return {
 					...res,
@@ -70,19 +115,281 @@ function gateOnDeliverable(inner, deliverable) {
 				verdict: gated ?? art.verdict
 			};
 		}
-	};
+	});
 }
-function isAsyncIterable$1(v) {
+function isAsyncIterable$2(v) {
 	return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 //#endregion
-//#region src/runtime/supervise/model-policy.ts
+//#region src/runtime/supervise/authoring.ts
+/**
+*
+* The supervisor's intelligence is AUTHORING the agents it spawns — not pressing buttons.
+*
+* Every agent here is three things: instructions (system prompt), tools, and a model — its
+* `AgentProfile`. The supervisor's job is to WRITE those profiles: read the task, decompose it,
+* and for each sub-task author a tailored worker recipe. `supervisorInstructions` is the how-to the
+* supervisor reads (its system prompt); `authoredWorker` builds a worker AGENT from a profile the
+* supervisor authored — the authored systemPrompt + model shape the worker's call.
+*
+* The skill is the single OPTIMIZABLE surface: edit it → the supervisor designs better agents.
+* That is the self-improvement lever (the prompt/skill lever), not the execution plumbing.
+*
+* @experimental
+*/
+/** Narrow an untyped `spawn_agent` profile argument to an `AuthoredProfile`, or null if the
+*  supervisor failed to author one (empty/placeholder profile — a skill violation worth catching). */
+function asAuthoredProfile(raw) {
+	const parsed = agentProfileSchema.safeParse(raw);
+	if (!parsed.success) return null;
+	const systemPrompt = parsed.data.prompt?.systemPrompt;
+	if (typeof systemPrompt !== "string" || systemPrompt.trim().length === 0) return null;
+	return {
+		...parsed.data,
+		name: typeof parsed.data.name === "string" && parsed.data.name.length > 0 ? parsed.data.name : "worker",
+		prompt: {
+			...parsed.data.prompt,
+			systemPrompt
+		}
+	};
+}
 /**
-* `assertModelAllowed` — a fail-loud guard that restricts a run to a chosen subset of
-* models. The two front doors (`supervise()` / `improve()`) call it once per configured
-* model at resolve time, so a run that names a model outside the allowed set throws before
-* any compute is spent — never silently swapped or silently allowed.
+* Lift a profile the supervisor AUTHORED into the canonical shape every executor reads.
+*
+* The skill asks for `systemPrompt` and `model` as flat fields — the vocabulary a model writes
+* well — while `AgentProfile` carries them as `prompt.systemPrompt` and `model.default`. Nothing
+* downstream reads the flat form: the router and cli-bridge leaves read `profile.prompt
+* .systemPrompt`, and the sandbox leaf hands the profile to a strict schema that REJECTS the flat
+* key outright (`Unrecognized key: "systemPrompt"`), which fails the worker's every round. Lift
+* both here, once, so what the supervisor writes is what the worker runs.
+*
+* Purely additive: a profile already canonical is returned untouched, and a flat field is dropped
+* only after its canonical slot is filled. Both spellings of the same standing instruction, set to
+* DIFFERENT text, is a contradiction with no safe reading — it fails loud, matching
+* `resolveSupervisorProfile`'s rule for the supervisor's own profile.
 */
+function canonicalizeAuthoredProfile(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw ?? {};
+	const authored = { ...raw };
+	const flatPrompt = authored.systemPrompt;
+	if (typeof flatPrompt === "string" && flatPrompt.trim().length > 0) {
+		const prompt = authored.prompt && typeof authored.prompt === "object" && !Array.isArray(authored.prompt) ? { ...authored.prompt } : {};
+		const canonicalPrompt = prompt.systemPrompt;
+		if (typeof canonicalPrompt === "string" && canonicalPrompt !== flatPrompt) throw new ValidationError(`canonicalizeAuthoredProfile: prompt.systemPrompt and systemPrompt are both set and differ — they are the same standing instruction, so author exactly one (prompt.systemPrompt: ${JSON.stringify(canonicalPrompt.slice(0, 80))}; systemPrompt: ${JSON.stringify(flatPrompt.slice(0, 80))})`);
+		if (typeof canonicalPrompt !== "string") prompt.systemPrompt = flatPrompt;
+		authored.prompt = prompt;
+		delete authored.systemPrompt;
+	}
+	if (typeof authored.model === "string" && authored.model.trim().length > 0) authored.model = { default: authored.model };
+	return authored;
+}
+/** The supervisor SKILL — the how-to the supervisor reads (its system prompt). THE optimizable
+*  surface: editing this changes how the supervisor designs every agent it spawns. */
+function supervisorInstructions(opts) {
+	return [
+		"You are a SUPERVISOR. You do NOT do the work yourself — your job is to DESIGN and DRIVE specialist worker agents.",
+		"",
+		"For the task you are given:",
+		"1. DECOMPOSE it into the smallest set of sub-tasks a single focused worker can each deliver.",
+		"2. For EACH sub-task, AUTHOR a worker by calling spawn_agent with a COMPLETE `profile`:",
+		"   • name and description: who this specialist is and why it exists.",
+		"   • prompt.systemPrompt: rich instructions for THIS sub-task — exact output, process, evidence, and what \"done\" means.",
+		"   • model.default, model.reasoningEffort, and harness: choose the execution system deliberately when the task benefits from it.",
+		"   • tools, mcp, resources.skills/files/instructions, hooks, subagents, permissions, and modes: grant or attach every capability the worker needs; omit an axis only when it is intentionally unnecessary.",
+		"   • metadata.role=\"driver\" when this child should be a sub-supervisor that may author and drive its own children.",
+		"   NEVER spawn a worker with an empty profile. The quality of the worker IS the quality of the profile you write.",
+		"3. await_event (kinds:['settled']) to collect each worker. Its result says valid:true only if the deployable check passed.",
+		"4. If a worker did NOT deliver, AUTHOR A NEW profile whose prompt.systemPrompt names the SPECIFIC failure and how to fix it — never just retry the same profile.",
+		"5. Stop (reply with no tool call) once the work is delivered. You cannot declare done yourself — only a delivered (valid:true) worker counts.",
+		...opts?.goal ? ["", `The goal: ${opts.goal}`] : []
+	].join("\n");
+}
+/** Build a router-only worker from an authored profile. This helper executes the prompt/model axes;
+*  use `workerFromBackend` for full materialization of tools, MCP, resources, hooks, and subagents. */
+function authoredWorker(profile, opts) {
+	const model = profile.model?.default ?? opts.cfg.model;
+	const executorFactory = (spec, ctx) => {
+		let artifact;
+		const executionId = ctx.node?.nodeId ?? `authored-router-${profile.name}`;
+		const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+		return gateOnDeliverable(attestRuntimeOwnedExecutor({
+			runtime: "router",
+			async execute(_t, signal) {
+				const res = await routerChatWithUsage({
+					...opts.cfg,
+					model
+				}, [{
+					role: "system",
+					content: profile.prompt.systemPrompt
+				}, {
+					role: "user",
+					content: opts.taskPrompt
+				}], {
+					temperature: opts.temperature ?? .4,
+					...signal ? { signal } : {}
+				});
+				artifact = {
+					outRef: contentAddress(res.content),
+					out: res.content,
+					spent: {
+						iterations: 1,
+						tokens: res.usage ?? {
+							input: 0,
+							output: 0
+						},
+						usd: res.costUsd ?? 0,
+						ms: 0
+					}
+				};
+				return artifact;
+			},
+			teardown: () => Promise.resolve({ destroyed: true }),
+			resultArtifact: () => {
+				if (!artifact) throw new Error("authoredWorker: resultArtifact read before execute");
+				return artifact;
+			}
+		}, {
+			effectiveProfile: spec.profile,
+			backend: "router",
+			model: {
+				status: "known",
+				id: model
+			},
+			execution: {
+				kind: "request",
+				id: executionId
+			},
+			materializer: "authored-router-prompt",
+			plan: {
+				kind: "authored-router-completion",
+				model,
+				temperature: opts.temperature ?? .4,
+				taskPrompt: opts.taskPrompt
+			}
+		}, {
+			attemptId,
+			binding: {
+				endpoint: opts.cfg.routerBaseUrl,
+				executionId,
+				model
+			},
+			descriptor: {
+				kind: "router-request",
+				transport: "http",
+				backend: "router"
+			}
+		}), opts.deliverable);
+	};
+	const spec = {
+		profile,
+		harness: null,
+		executorFactory
+	};
+	return {
+		name: profile.name,
+		act: async () => "",
+		executorSpec: spec
+	};
+}
+/** Default thresholds for `ProfileRichnessThresholds` — 600 chars / 6 lines minimum system prompt. */
+const defaultProfileRichnessThresholds = {
+	minSystemPromptChars: 600,
+	minSystemPromptLines: 6
+};
+/** Read the system prompt from any authored shape: canonical `prompt.systemPrompt`, the sandbox
+*  `prompt.system` convention, or a bare-string `prompt`. */
+function resolveSystemPrompt(profile) {
+	const pr = profile.prompt;
+	if (typeof pr === "string") return pr;
+	if (pr && typeof pr === "object") {
+		const o = pr;
+		if (typeof o.systemPrompt === "string") return o.systemPrompt;
+		if (typeof o.system === "string") return o.system;
+	}
+	return "";
+}
+/** OBSERVE one authored `AgentProfile` and score its richness (no judge verdict is read). The task
+*  context (`needsMcp`) lets a domain say "this work needs a data/tool MCP" so a missing MCP counts. */
+function assessAuthoredProfile(profile, opts) {
+	const th = {
+		...defaultProfileRichnessThresholds,
+		...opts?.thresholds ?? {}
+	};
+	const systemPrompt = resolveSystemPrompt(profile);
+	const trimmed = systemPrompt.trim();
+	const systemPromptChars = trimmed.length;
+	const systemPromptLines = trimmed ? trimmed.split("\n").filter((l) => l.trim().length > 0).length : 0;
+	const sentenceCount = trimmed ? (trimmed.match(/[.!?](\s|$)/g) ?? []).length || (trimmed ? 1 : 0) : 0;
+	const hasDescription = typeof profile.description === "string" && profile.description.trim().length > 0;
+	const tools = profile.tools;
+	const hasTools = !!tools && Object.keys(tools).length > 0;
+	const skills = profile.resources?.skills;
+	const hasSkills = Array.isArray(skills) && skills.length > 0;
+	const mcp = profile.mcp;
+	const hasMcp = !!mcp && Object.keys(mcp).length > 0;
+	const subagents = profile.subagents;
+	const hasSubagents = !!subagents && Object.keys(subagents).length > 0;
+	const reasons = [];
+	const promptThin = systemPromptChars < th.minSystemPromptChars || systemPromptLines < th.minSystemPromptLines;
+	if (promptThin) reasons.push(`system prompt is thin (${systemPromptChars} chars, ${systemPromptLines} lines; need ≥${th.minSystemPromptChars} chars and ≥${th.minSystemPromptLines} lines)`);
+	if (!hasTools) reasons.push("no tools granted (a worker can only act through the tools you grant it)");
+	if (!hasSkills) reasons.push("no skills attached (no reusable how-to notes injected)");
+	if (opts?.needsMcp && !hasMcp) reasons.push("no MCP server, but the task needs data/tool access");
+	const signals = [
+		!promptThin,
+		hasTools,
+		hasSkills,
+		hasDescription,
+		opts?.needsMcp ? hasMcp : true
+	];
+	const richness = signals.filter(Boolean).length / signals.length;
+	const thin = promptThin || !hasTools && !hasSkills && !hasMcp;
+	return {
+		name: profile.name ?? "worker",
+		systemPrompt,
+		systemPromptChars,
+		systemPromptLines,
+		sentenceCount,
+		hasDescription,
+		hasTools,
+		hasSkills,
+		hasMcp,
+		hasSubagents,
+		richness,
+		thin,
+		reasons
+	};
+}
+/** Turn a {@link ProfileRichness} verdict into a bus-routable `AnalystFinding` (area `profile-quality`).
+*  Severity scales with thinness; the recommended action names the MISSING lever so the supervisor can
+*  re-author. `subject` = the worker name so per-worker findings diff cleanly across re-authors. */
+function profileRichnessFinding(richness, opts) {
+	const analyst_id = opts?.analystId ?? "profile-richness";
+	const subject = richness.name;
+	const claim = richness.thin ? `Worker "${richness.name}" was authored as a THIN profile: ${richness.reasons.join("; ")}.` : `Worker "${richness.name}" was authored as a rich profile (richness ${(richness.richness * 100).toFixed(0)}%).`;
+	return makeFinding({
+		analyst_id,
+		severity: richness.thin ? richness.richness < .25 ? "high" : "medium" : "info",
+		area: "profile-quality",
+		claim,
+		subject,
+		confidence: .9,
+		evidence_refs: [{
+			kind: "metric",
+			uri: `profile:${subject}`,
+			excerpt: `chars=${richness.systemPromptChars} lines=${richness.systemPromptLines} tools=${richness.hasTools} skills=${richness.hasSkills} mcp=${richness.hasMcp} richness=${richness.richness.toFixed(2)}`
+		}],
+		...richness.thin ? { recommended_action: `Re-author "${richness.name}" with: ${richness.reasons.join("; ")}.` } : {},
+		id_basis: computeFindingId({
+			analyst_id,
+			area: "profile-quality",
+			subject,
+			claim: `richness:${richness.thin ? "thin" : "rich"}`
+		})
+	});
+}
+//#endregion
+//#region src/runtime/supervise/model-policy.ts
 /**
 * Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
 * member of `allowed`. No-op when `allowed` is unset (the unrestricted default) or when
@@ -92,6 +399,14 @@ function assertModelAllowed(model, allowed) {
 	if (!allowed || model === void 0) return;
 	if (!allowed.includes(model)) throw new ConfigError(`model ${JSON.stringify(model)} is not in the allowed set ${JSON.stringify([...allowed])}`);
 }
+/** Check every canonical model-bearing field in a complete profile, including the models a
+* backend may select for cheap work, named subagents, or modes. */
+function assertProfileModelsAllowed(profile, allowed) {
+	assertModelAllowed(profile.model?.default, allowed);
+	assertModelAllowed(profile.model?.small, allowed);
+	for (const subagent of Object.values(profile.subagents ?? {})) assertModelAllowed(subagent.model, allowed);
+	for (const mode of Object.values(profile.modes ?? {})) assertModelAllowed(mode.model, allowed);
+}
 //#endregion
 //#region src/runtime/supervise/otel-spans.ts
 /**
@@ -402,59 +717,96 @@ function truncate(value) {
 }
 //#endregion
 //#region src/runtime/supervise/coordination-log.ts
-/** Should this bus event be persisted? Questions and findings ARE the prior context a resumed
-*  driver needs; answers fold their status; everything else has a better ledger or none. */
+/**
+* Durable side-log for coordination evidence the spawn journal does not own: questions, analyst
+* findings, answer decisions, authorized continuation receipts, delivery-attempt markers, and
+* delivery outcomes. A durable run
+* (`supervise({ runDir })`) appends them as they publish and loads them on resume, so a restarted
+* coordinator retains the exact evidence produced by prior processes.
+*
+* Answer down-events also fold status on load: a question answered before the crash reloads as
+* `answered`, not as a re-blocking `open`. Settled events are skipped (the spawn journal is their
+* ledger). A receipt followed by an attempt but no outcome proves the process died in the delivery
+* window; that outcome remains unknown and no prior instruction is auto-delivered.
+*
+* JSONL, one fsynced record per event, keyed by `runId` — several runs may share one log file
+* exactly as they share one spawn-journal file.
+*
+* @experimental
+*/
+/** Persist prior context plus exact continuation authorization, attempt, and result evidence.
+* Settlements have their own journal. */
 function persisted(event) {
-	return event.type === "question" || event.type === "finding" || event.type === "answer";
+	return event.type !== "settled";
 }
 /** FS-backed `CoordinationLog`: append-only JSONL, fsynced per record. */
 var FileCoordinationLog = class {
 	path;
+	appendTail = Promise.resolve();
 	constructor(path) {
 		this.path = path;
 	}
-	async append(runId, event, at) {
-		if (!persisted(event)) return;
+	async append(runId, record, ownerId) {
+		if (!persisted(record.event)) return;
+		const append = this.appendTail.then(() => this.appendRecord(runId, record, ownerId));
+		this.appendTail = append.catch(() => void 0);
+		return append;
+	}
+	async appendRecord(runId, busRecord, ownerId) {
 		const fs = await import("node:fs/promises");
 		const path = await import("node:path");
 		await fs.mkdir(path.dirname(this.path), { recursive: true });
 		const record = {
 			runId,
-			at,
-			event
+			...ownerId !== void 0 ? { ownerId } : {},
+			...busRecord
 		};
+		const needsSeparator = await prepareJsonlAppend(this.path);
 		const fh = await fs.open(this.path, "a");
 		try {
-			await fh.write(`${JSON.stringify(record)}\n`);
+			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
 			await fh.sync();
 		} finally {
 			await fh.close();
 		}
 	}
-	async load(runId) {
+	async load(runId, ownerId) {
 		const fs = await import("node:fs/promises");
 		let text;
 		try {
 			text = await fs.readFile(this.path, "utf8");
 		} catch (err) {
-			if (isNoEntError(err)) return {
-				questions: [],
-				findings: []
-			};
+			if (isNoEntError(err)) return emptyPriorCoordination(ownerId);
 			throw err;
 		}
 		const byId = /* @__PURE__ */ new Map();
 		const findings = [];
-		for (const line of text.split("\n")) {
-			if (line.length === 0) continue;
-			const record = JSON.parse(line);
-			if (record.runId !== runId) continue;
+		const continuations = [];
+		const deliveryEvidence = [];
+		const records = [];
+		let legacySeq = 0;
+		for (const stored of parseCommittedJsonLines(text, this.path)) {
+			if (stored.runId !== runId) continue;
+			if (ownerId !== void 0 && stored.ownerId !== ownerId) continue;
+			const record = "seq" in stored ? {
+				seq: stored.seq,
+				at: stored.at,
+				priority: stored.priority,
+				event: stored.event
+			} : {
+				seq: legacySeq++,
+				at: Date.parse(stored.at),
+				priority: 0,
+				event: stored.event
+			};
+			records.push(record);
 			const ev = record.event;
+			if (ev.type === "delivery-attempt" || ev.type === "steer" || ev.type === "answer") deliveryEvidence.push(ev);
 			if (ev.type === "question") byId.set(ev.question.id, ev.question);
 			else if (ev.type === "finding") findings.push(ev.finding);
 			else if (ev.type === "answer") {
 				const prior = byId.get(ev.questionId);
-				if (prior) byId.set(ev.questionId, {
+				if (prior && ev.down.delivered) byId.set(ev.questionId, {
 					...prior,
 					status: "answered",
 					decision: {
@@ -463,14 +815,28 @@ var FileCoordinationLog = class {
 						by: "prior-run"
 					}
 				});
-			}
+			} else if (ev.type === "instruction") continuations.push(ev.instruction);
 		}
 		return {
+			...ownerId !== void 0 ? { ownerId } : {},
 			questions: [...byId.values()],
-			findings
+			findings,
+			continuations,
+			deliveryEvidence,
+			records
 		};
 	}
 };
+function emptyPriorCoordination(ownerId) {
+	return {
+		...ownerId !== void 0 ? { ownerId } : {},
+		questions: [],
+		findings: [],
+		continuations: [],
+		deliveryEvidence: [],
+		records: []
+	};
+}
 function isNoEntError(err) {
 	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
@@ -1561,9 +1927,10 @@ function createInbox() {
 	return {
 		deliver(msg) {
 			const m = parseDown(msg);
-			if (!m) return;
+			if (!m) return false;
 			pending.push(m);
 			if (m.interrupt && live && !live.signal.aborted) live.abort();
+			return true;
 		},
 		drain() {
 			return pending.splice(0, pending.length);
@@ -2220,8 +2587,8 @@ function sandboxSessionTraceSource(box, sessionId, opts = {}) {
 * | `profile.prompt.systemPrompt` | honored — prepended to the task text (pi RPC takes no separate system-prompt channel) |
 * | `profile.mcp` | honored — written to this execution's own file and passed as `--mcp-config` for `pi-mcp-adapter`; see `pi-mcp.ts` |
 * | `profile.extensions.pi.load` | honored — lowered to `--no-extensions` + `--extension <abs>` |
-* | `profile.prompt.instructions` | DROPPED — fold into `systemPrompt` before calling |
-* | `profile.model` | DROPPED — the seam's `model` is the only model channel; a profile that disagrees with the seam is silently overridden by the seam |
+* | `profile.prompt.instructions` | honored — appended to the system prompt, one per line |
+* | `profile.model.default` | honored — overrides the seam's `model`; the seam is the fallback for profiles that select none |
 * | `profile.model.reasoningEffort` | DROPPED — no `--thinking` flag is emitted, so pi's configured `defaultThinkingLevel` applies |
 * | `profile.tools` | DROPPED — no `--no-tools` / allow-deny mapping; pi runs its full builtin tool set |
 * | `profile.permissions` | DROPPED |
@@ -2242,12 +2609,17 @@ const PI_RUNTIME = "pi";
 const piSeamKey = "pi";
 /** Build the `Executor` for one pi worker. Registered as runtime `'pi'`. */
 const piExecutor = (spec, ctx) => {
-	const seam = readPiSeam(ctx);
+	const seam = {
+		...readPiSeam(ctx),
+		...spec.profile.model?.default ? { model: spec.profile.model.default } : {}
+	};
 	const traceEnv = workerTraceEnv(ctx);
 	const inbox = createInbox();
 	const activity = createActivityLog(seam.activityWindow ?? 12);
 	const runId = `pi-${spec.profile.name ?? "worker"}-${Date.now()}`;
 	const trace = createPushTraceSource({ runId });
+	const executionId = ctx.node?.nodeId ?? `pi-run-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
 	const derived = [];
 	const controller = new AbortController();
 	const cascade = () => controller.abort();
@@ -2260,7 +2632,7 @@ const piExecutor = (spec, ctx) => {
 		proc: void 0,
 		artifact: void 0
 	};
-	return {
+	const executor = {
 		runtime: "pi",
 		deliver: (m) => inbox.deliver(m),
 		progress: () => ({
@@ -2301,6 +2673,44 @@ const piExecutor = (spec, ctx) => {
 			return state.artifact;
 		}
 	};
+	if (ctx.node === void 0) return executor;
+	return attestRuntimeOwnedExecutor(executor, {
+		effectiveProfile: spec.profile,
+		backend: "pi",
+		model: seam.model ? {
+			status: "known",
+			id: seam.model
+		} : {
+			status: "unknown",
+			reason: "pi selected its configured default model"
+		},
+		execution: {
+			kind: "run",
+			id: executionId
+		},
+		materializer: "pi-rpc-agent-profile",
+		plan: {
+			kind: "pi-rpc-session",
+			bin: seam.bin ?? "pi",
+			args: seam.args ?? [],
+			cwd: seam.cwd ?? null,
+			model: seam.model ?? null,
+			turnTimeoutMs: seam.turnTimeoutMs ?? null
+		}
+	}, {
+		attemptId,
+		binding: {
+			executionId,
+			bin: seam.bin ?? "pi",
+			cwd: seam.cwd ?? null,
+			model: seam.model ?? null
+		},
+		descriptor: {
+			kind: "pi-rpc-run",
+			transport: "process",
+			backend: "pi"
+		}
+	});
 };
 /**
 * One pi RPC session, run to `agent_settled`. Every steer delivered while the turn is in flight is
@@ -2317,6 +2727,7 @@ async function* streamPiSession(args) {
 	};
 	let usd = 0;
 	let usdKnown = true;
+	let tokensKnown = true;
 	throwIfAborted(args.signal);
 	throwIfAborted(args.controller.signal);
 	const piMcp = preparePiMcp(args.spec.profile, {
@@ -2383,7 +2794,7 @@ async function* streamPiSession(args) {
 	};
 	args.signal.addEventListener("abort", abortAll, { once: true });
 	args.controller.signal.addEventListener("abort", abortAll, { once: true });
-	const system = args.spec.profile.prompt?.systemPrompt;
+	const system = [args.spec.profile.prompt?.systemPrompt, ...args.spec.profile.prompt?.instructions ?? []].filter((line) => typeof line === "string" && line.trim().length > 0).join("\n");
 	const opening = system ? `${system}\n\n${taskText(args.task)}` : taskText(args.task);
 	const deadline = seam.turnTimeoutMs ? Date.now() + seam.turnTimeoutMs : void 0;
 	const sendPrompt = (message, streamingBehavior) => {
@@ -2413,6 +2824,7 @@ async function* streamPiSession(args) {
 				}
 				const projected = projectPiEvent(ev, args, tokens, pendingTools);
 				if (projected.assistant) lastAssistant = projected.assistant;
+				if (projected.tokensUnknown) tokensKnown = false;
 				for (const usage of projected.events) {
 					if (usage.kind === "cost") {
 						usd += usage.usd;
@@ -2466,6 +2878,7 @@ async function* streamPiSession(args) {
 	const spent = {
 		iterations: state.turns,
 		tokens,
+		...tokensKnown ? {} : { tokensKnown: false },
 		usd,
 		...usdKnown ? {} : { usdKnown: false },
 		ms: Date.now() - started
@@ -2569,9 +2982,11 @@ function projectPiEvent(ev, args, tokens, pendingTools) {
 		});
 		out.push({ kind: "iteration" });
 		const assistant = readAssistantOutcome(ev.message);
+		const tokensUnknown = !usage || usage.tokensKnown === false;
 		return {
 			events: out,
-			...assistant ? { assistant } : {}
+			...assistant ? { assistant } : {},
+			...tokensUnknown ? { tokensUnknown: true } : {}
 		};
 	}
 	return { events: out };
@@ -2584,14 +2999,18 @@ function readUsage(message) {
 	const usage = message.usage;
 	if (!usage || typeof usage !== "object") return void 0;
 	const u = usage;
-	const input = num(u.prompt_tokens) ?? (num(u.input) ?? num(u.inputTokens) ?? 0) + (num(u.cacheRead) ?? num(u.cache_read_input_tokens) ?? num(u.cacheReadInputTokens) ?? 0) + (num(u.cacheWrite) ?? num(u.cache_creation_input_tokens) ?? num(u.cacheCreationInputTokens) ?? 0);
-	const output = num(u.output) ?? num(u.outputTokens) ?? num(u.completion_tokens) ?? 0;
+	const promptTokens = num(u.prompt_tokens);
+	const freshInput = num(u.input) ?? num(u.inputTokens);
+	const outputRaw = num(u.output) ?? num(u.outputTokens) ?? num(u.completion_tokens);
+	const input = promptTokens ?? (freshInput ?? 0) + (num(u.cacheRead) ?? num(u.cache_read_input_tokens) ?? num(u.cacheReadInputTokens) ?? 0) + (num(u.cacheWrite) ?? num(u.cache_creation_input_tokens) ?? num(u.cacheCreationInputTokens) ?? 0);
+	const output = outputRaw ?? 0;
 	const costRaw = u.cost;
 	const reportedUsd = num(costRaw) ?? (costRaw && typeof costRaw === "object" ? num(costRaw.total) ?? num(costRaw.totalCost) : void 0);
 	return {
 		input,
 		output,
-		...reportedUsd !== void 0 && reportedUsd > 0 ? { usd: reportedUsd } : {}
+		...reportedUsd !== void 0 && reportedUsd > 0 ? { usd: reportedUsd } : {},
+		tokensKnown: promptTokens !== void 0 || freshInput !== void 0 || outputRaw !== void 0
 	};
 }
 function readAssistantOutcome(message) {
@@ -3026,34 +3445,38 @@ function readPromptOptions(loopCtx) {
 * Build a worktree-CLI leaf `Executor`. Per-spawn (a fresh worktree + abort + teardown each), so a
 * fanout of N profiles = N parallel worktrees that never clobber each other.
 *
-* Fail-loud: an empty `repoRoot`/`harness`/`taskPrompt` throws at construction. `resultArtifact()`
-* before `execute()` resolves throws.
+* Fail-loud: an empty `repoRoot`/`harness` or an explicitly empty `taskPrompt` throws at
+* construction. Calling `execute(undefined, signal)` without a configured prompt throws before a
+* worktree is created. `resultArtifact()` before `execute()` resolves throws.
 *
 * @experimental
 */
 function createWorktreeCliExecutor(options) {
 	if (!options.repoRoot) throw new ValidationError("createWorktreeCliExecutor: repoRoot required");
 	if (!options.harness) throw new ValidationError("createWorktreeCliExecutor: harness required");
-	if (typeof options.taskPrompt !== "string" || options.taskPrompt.length === 0) throw new ValidationError("createWorktreeCliExecutor: taskPrompt required");
+	if (options.taskPrompt !== void 0 && (typeof options.taskPrompt !== "string" || options.taskPrompt.length === 0)) throw new ValidationError("createWorktreeCliExecutor: taskPrompt required");
 	if (options.codexReproducible && options.harness !== "codex") throw new ValidationError("createWorktreeCliExecutor: codexReproducible requires harness \"codex\"");
 	if (options.codexReproducible && options.budgetExempt === true) throw new ValidationError("createWorktreeCliExecutor: codexReproducible cannot be budgetExempt");
 	if (options.codexReadDeniedPaths !== void 0 && !options.codexReproducible) throw new ValidationError("createWorktreeCliExecutor: codexReadDeniedPaths requires codexReproducible");
 	const runId = options.runId ?? randomUUID();
+	const attemptId = options.executionAttemptId ?? newExecutionAttemptId(runId);
 	const controller = new AbortController();
 	const budgetExempt = options.budgetExempt ?? !options.codexReproducible;
 	let run;
 	let artifact;
-	return {
+	const profilePlan = worktreeProfileExecutionPlan(options.profile, options.harness);
+	return attestRuntimeOwnedExecutor({
 		runtime: "cli",
 		budgetExempt,
-		async execute(_task, signal) {
+		async execute(task, signal) {
 			const linked = linkSignals$1(signal, controller.signal);
 			const started = Date.now();
+			const taskPrompt = executionTaskPrompt(task, options.taskPrompt);
 			run = await runWorktreeHarness({
 				repoRoot: options.repoRoot,
 				profile: options.profile,
 				harness: options.harness,
-				taskPrompt: options.taskPrompt,
+				taskPrompt,
 				runId,
 				...options.baseRef ? { baseRef: options.baseRef } : {},
 				...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
@@ -3108,7 +3531,65 @@ function createWorktreeCliExecutor(options) {
 			if (!artifact) throw new ValidationError("createWorktreeCliExecutor: resultArtifact() read before execute() resolved");
 			return artifact;
 		}
-	};
+	}, {
+		effectiveProfile: options.profile,
+		backend: `cli-worktree:${options.harness}`,
+		model: options.profile.model?.default ? {
+			status: "known",
+			id: options.profile.model.default
+		} : {
+			status: "unknown",
+			reason: `${options.harness} selected its configured default model`
+		},
+		execution: {
+			kind: "worktree-run",
+			id: runId
+		},
+		materializer: "agent-profile-worktree-plan",
+		plan: {
+			kind: "worktree-cli",
+			profilePlan,
+			harness: options.harness,
+			baseRef: options.baseRef ?? "HEAD",
+			harnessTimeoutMs: options.harnessTimeoutMs ?? null,
+			codexReproducible: options.codexReproducible === true,
+			codexReadDeniedPaths: options.codexReadDeniedPaths ?? [],
+			testCmd: options.testCmd ?? null,
+			typecheckCmd: options.typecheckCmd ?? null,
+			checkTimeoutMs: options.checkTimeoutMs ?? null,
+			checkOutputCap: options.checkOutputCap ?? 16e3
+		}
+	}, {
+		attemptId,
+		binding: {
+			repoRoot: options.repoRoot,
+			runId,
+			harness: options.harness,
+			model: options.profile.model?.default ?? null,
+			baseRef: options.baseRef ?? "HEAD"
+		},
+		descriptor: {
+			kind: "worktree-cli-run",
+			transport: "process",
+			backend: options.harness
+		}
+	});
+}
+/** A scoped execution task is authoritative. The configured prompt remains only as the
+* unambiguous direct-call default for existing `execute(undefined, signal)` consumers. */
+function executionTaskPrompt(task, configuredPrompt) {
+	if (task === void 0) {
+		if (configuredPrompt !== void 0) return configuredPrompt;
+		throw new ValidationError("createWorktreeCliExecutor: execute task required when taskPrompt is not configured");
+	}
+	if (typeof task === "string") return task;
+	try {
+		const encoded = JSON.stringify(task);
+		if (encoded !== void 0) return encoded;
+	} catch (error) {
+		throw new ValidationError("createWorktreeCliExecutor: execute task must be JSON-serializable", { cause: error });
+	}
+	throw new ValidationError("createWorktreeCliExecutor: execute task must be JSON-serializable");
 }
 /** Link two abort signals into one that fires when either does. Returns `undefined` when neither
 *  is present so the harness runner gets no signal at all. */
@@ -3195,7 +3676,7 @@ function zeroSpend() {
 */
 const routerInlineExecutor = (spec, ctx) => {
 	const seam = readSeam(ctx, routerSeamKey, "router/inline");
-	const model = seam.model ?? spec.profile.model?.default;
+	const model = spec.profile.model?.default ?? seam.model;
 	if (!model) throw new ValidationError("routerInlineExecutor: no model — set RouterSeam.model or AgentProfile.model.default");
 	if (!seam.routerBaseUrl || !seam.routerKey) throw new ValidationError("routerInlineExecutor: RouterSeam.routerBaseUrl + routerKey required");
 	const controller = new AbortController();
@@ -3205,7 +3686,9 @@ const routerInlineExecutor = (spec, ctx) => {
 	abortIfSignalled();
 	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
 	let artifact;
-	return {
+	const executionId = ctx.node?.nodeId ?? `router-request-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	return attestRuntimeOwnedExecutor({
 		runtime: "router",
 		async execute(task, signal) {
 			const messages = taskToMessages(task, spec);
@@ -3223,6 +3706,8 @@ const routerInlineExecutor = (spec, ctx) => {
 					output: r.usage.output
 				} : zeroTokenUsage(),
 				usd: r.costUsd ?? 0,
+				...r.usage ? {} : { tokensKnown: false },
+				...r.costUsd === void 0 ? { usdKnown: false } : {},
 				ms: Date.now() - started
 			};
 			const out = { content: r.content };
@@ -3247,7 +3732,35 @@ const routerInlineExecutor = (spec, ctx) => {
 				spent: artifact.spent
 			};
 		}
-	};
+	}, {
+		effectiveProfile: spec.profile,
+		backend: "router",
+		model: {
+			status: "known",
+			id: model
+		},
+		execution: {
+			kind: "request",
+			id: executionId
+		},
+		materializer: "router-prompt-model",
+		plan: {
+			kind: "openai-chat-completion",
+			model
+		}
+	}, {
+		attemptId,
+		binding: {
+			endpoint: seam.routerBaseUrl,
+			executionId,
+			model
+		},
+		descriptor: {
+			kind: "router-request",
+			transport: "http",
+			backend: "router"
+		}
+	});
 };
 const routerToolsSeamKey = "router-tools";
 /**
@@ -3256,7 +3769,7 @@ const routerToolsSeamKey = "router-tools";
 */
 const routerToolsInlineExecutor = (spec, ctx) => {
 	const seam = readSeam(ctx, routerToolsSeamKey, "router-tools");
-	const model = seam.model ?? spec.profile.model?.default;
+	const model = spec.profile.model?.default ?? seam.model;
 	if (!model) throw new ValidationError("routerToolsInlineExecutor: no model — set RouterToolsSeam.model or AgentProfile.model.default");
 	if (!seam.routerBaseUrl || !seam.routerKey) throw new ValidationError("routerToolsInlineExecutor: RouterToolsSeam.routerBaseUrl + routerKey required");
 	const maxTurns = seam.maxTurns ?? 200;
@@ -3268,13 +3781,16 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
 	const inbox = createInbox();
 	let artifact;
-	return {
+	const executionId = ctx.node?.nodeId ?? `router-tools-run-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	return attestRuntimeOwnedExecutor({
 		runtime: "router",
 		deliver: (m) => inbox.deliver(m),
 		async execute(task, signal) {
 			const started = Date.now();
 			const messages = [...taskToMessages(task, spec)];
 			const tokens = zeroTokenUsage();
+			let tokensKnown = true;
 			let turns = 0;
 			let lastText = "";
 			const flush = () => {
@@ -3325,7 +3841,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 				if (u && typeof u.prompt_tokens === "number" && typeof u.completion_tokens === "number") {
 					tokens.input += u.prompt_tokens;
 					tokens.output += u.completion_tokens;
-				}
+				} else tokensKnown = false;
 				const msg = data.choices?.[0]?.message;
 				if (msg?.content) lastText = msg.content;
 				const toolCalls = msg?.tool_calls ?? [];
@@ -3387,11 +3903,14 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 					} catch {}
 				}
 			}
-			const usd = isModelPriced(model) ? estimateCost(tokens.input, tokens.output, model) : 0;
+			const priced = isModelPriced(model);
+			const usd = priced ? estimateCost(tokens.input, tokens.output, model) : 0;
 			const spent = {
 				iterations: turns,
 				tokens,
+				...tokensKnown ? {} : { tokensKnown: false },
 				usd,
+				...!priced || !tokensKnown ? { usdKnown: false } : {},
 				ms: Date.now() - started
 			};
 			const out = { content: lastText };
@@ -3416,7 +3935,37 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 				spent: artifact.spent
 			};
 		}
-	};
+	}, {
+		effectiveProfile: spec.profile,
+		backend: "router-tools",
+		model: {
+			status: "known",
+			id: model
+		},
+		execution: {
+			kind: "run",
+			id: executionId
+		},
+		materializer: "router-tools-prompt-model",
+		plan: {
+			kind: "openai-tool-loop",
+			model,
+			maxTurns,
+			tools: seam.tools
+		}
+	}, {
+		attemptId,
+		binding: {
+			endpoint: seam.routerBaseUrl,
+			executionId,
+			model
+		},
+		descriptor: {
+			kind: "router-tool-loop",
+			transport: "http",
+			backend: "router-tools"
+		}
+	});
 };
 /**
 * COMPOSES `runAgentRounds` as a single-task leaf: one box, a refine driver bounded to
@@ -3445,11 +3994,48 @@ const sandboxExecutor = (spec, ctx) => {
 	abortIfSignalled();
 	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
 	let artifact;
-	if (seam.steering) {
-		const inbox = createInbox();
-		const session = createSteerableSandboxSession({
-			controller,
-			profile: spec.profile,
+	const executionId = ctx.node?.nodeId ?? `sandbox-run-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	const sandboxMaterialization = {
+		effectiveProfile: spec.profile,
+		backend: harness,
+		model: spec.profile.model?.default ? {
+			status: "known",
+			id: spec.profile.model.default
+		} : {
+			status: "unknown",
+			reason: "sandbox harness selected its default model"
+		},
+		execution: {
+			kind: "run",
+			id: executionId
+		},
+		materializer: "sandbox-agent-profile",
+		plan: {
+			kind: "sandbox-agent-rounds",
+			harness,
+			maxIterations,
+			steering: seam.steering !== void 0
+		}
+	};
+	const sandboxBinding = {
+		attemptId,
+		binding: {
+			executionId,
+			harness,
+			model: spec.profile.model?.default ?? null
+		},
+		descriptor: {
+			kind: "sandbox-run",
+			transport: "sandbox",
+			backend: harness
+		}
+	};
+	if (seam.steering) {
+		const inbox = createInbox();
+		const session = createSteerableSandboxSession({
+			controller,
+			profile: spec.profile,
 			harness,
 			sandboxClient: seam.sandboxClient,
 			inbox,
@@ -3459,7 +4045,7 @@ const sandboxExecutor = (spec, ctx) => {
 			...Object.keys(traceEnv).length > 0 ? { traceEnv } : {},
 			contentRef
 		});
-		return {
+		return attestRuntimeOwnedExecutor({
 			runtime: "sandbox",
 			deliver: (m) => inbox.deliver(m),
 			progress: () => session.progress(),
@@ -3477,13 +4063,13 @@ const sandboxExecutor = (spec, ctx) => {
 				if (!a) throw new ValidationError("sandboxExecutor(steering): resultArtifact() read before stream drained");
 				return a;
 			}
-		};
+		}, sandboxMaterialization, sandboxBinding);
 	}
 	const output = { parse(events) {
 		return { events };
 	} };
 	const driver = singleShotDriver(maxIterations);
-	return {
+	return attestRuntimeOwnedExecutor({
 		runtime: "sandbox",
 		execute(task, signal) {
 			return streamSandboxLeaf({
@@ -3511,7 +4097,7 @@ const sandboxExecutor = (spec, ctx) => {
 			if (!artifact) throw new ValidationError("sandboxExecutor: resultArtifact() read before stream drained");
 			return artifact;
 		}
-	};
+	}, sandboxMaterialization, sandboxBinding);
 };
 async function* streamSandboxLeaf(args) {
 	const linked = new AbortController();
@@ -3547,8 +4133,10 @@ async function* streamSandboxLeaf(args) {
 	};
 	try {
 		const result = await runAgentRounds(loopOptions);
+		const failure = failedRound(result);
+		if (failure) throw failure;
 		const out = result.winner?.output ?? { events: [] };
-		const verdict = result.winner?.verdict;
+		const verdict = result.winner?.verdict ?? leafVerdict(result);
 		const spent = {
 			iterations: result.iterations.length,
 			tokens: {
@@ -3582,11 +4170,39 @@ async function* streamSandboxLeaf(args) {
 		args.controller.signal.removeEventListener("abort", cascade);
 	}
 }
+/** The loop's own failure, when NO iteration produced an output: the first error it
+*  recorded, renamed so the settled worker names the leaf it died in. `undefined`
+*  when any iteration produced an output — a partly-failed round still has material
+*  to settle on. */
+function failedRound(result) {
+	if (result.iterations.length === 0) return void 0;
+	if (result.iterations.some((iteration) => iteration.output !== void 0)) return void 0;
+	const first = result.iterations.find((iteration) => iteration.error)?.error;
+	if (!first) return void 0;
+	return new Error(`sandboxExecutor: agent round failed — ${first.message}`, { cause: first });
+}
+/**
+* The leaf's OWN verdict, for a round the loop scored no validator against.
+*
+* `settled ⟺ delivered` is written by the completion oracle, and a caller that
+* passes one keeps it: `gateOnDeliverable` wraps this executor and overrides
+* `valid` from its check. This is the sandbox backend's structural answer for a
+* run with no oracle at all — without it nothing ever writes `valid`, no settled
+* child is ever DELIVERED, and the finalizer has nothing to select no matter how
+* well the worker ran. Structural, never self-reported: the harness completed a
+* round and returned an output artifact, or it did not.
+*/
+function leafVerdict(result) {
+	if (result.winner?.output === void 0) return void 0;
+	return {
+		valid: true,
+		score: 1
+	};
+}
 /**
 * Spawns a subprocess (`bin` + `args`). It cannot account tokens, so it is
-* `budgetExempt: true`: its spend is NOT metered against the conserved pool and
-* its iterations are EXCLUDED from the equal-k arms by construction (the
-* resolver/equal-k path checks `budgetExempt`). teardown is SIGTERM → SIGKILL
+* `budgetExempt: true`: it remains usable as a direct executor, while budgeted supervision
+* refuses it before process execution because the CLI exposes no usage receipt. teardown is SIGTERM → SIGKILL
 * with a grace window. Streaming: yields one `iteration` event on clean exit.
 */
 const cliExecutor = (_spec, ctx) => {
@@ -3601,7 +4217,9 @@ const cliExecutor = (_spec, ctx) => {
 	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
 	let proc;
 	let artifact;
-	return {
+	const executionId = ctx.node?.nodeId ?? `cli-process-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	return attestRuntimeOwnedExecutor({
 		runtime: "cli",
 		budgetExempt: true,
 		execute(task, signal) {
@@ -3628,7 +4246,39 @@ const cliExecutor = (_spec, ctx) => {
 			if (!artifact) throw new ValidationError("cliExecutor: resultArtifact() read before stream drained");
 			return artifact;
 		}
-	};
+	}, {
+		effectiveProfile: _spec.profile,
+		backend: "cli",
+		model: {
+			status: "unknown",
+			reason: "raw subprocess has no model identity contract"
+		},
+		execution: {
+			kind: "process-attempt",
+			id: executionId
+		},
+		materializer: "raw-cli-stdin",
+		plan: {
+			kind: "raw-cli-process",
+			bin: seam.bin,
+			args: seam.args ?? [],
+			cwd: seam.cwd ?? null,
+			envOverrides: seam.env ?? {},
+			ambientEnvironment: "inherited"
+		}
+	}, {
+		attemptId,
+		binding: {
+			executionId,
+			bin: seam.bin,
+			cwd: seam.cwd ?? null
+		},
+		descriptor: {
+			kind: "cli-process",
+			transport: "process",
+			backend: "cli"
+		}
+	});
 };
 async function* streamCliLeaf(args) {
 	const prompt = taskToPrompt(args.task);
@@ -3717,33 +4367,34 @@ function killWithGrace(proc, grace) {
 *  - STEERABLE: the down-leg `inbox` is drained at each turn boundary; a queued
 *    steer becomes the next turn's prompt on the same session, and the worker can't
 *    settle while a steer it never read is pending (the sandbox/router contract).
-*  - ABORT: the caller signal + teardown fold into the per-turn fetch signal; a
-*    forceful (`interrupt`) steer aborts the in-flight turn so the worker re-plans.
+*  - ABORT: reader abort only detaches HTTP. Interrupt/teardown then call the
+*    bridge's explicit cancel operation and wait for the owned run to terminate.
 *
 * Reports REAL usage when the bridge surfaces it, never a fabricated cost.
 */
-/** Resolve the bridge wire model for this spawn: a per-create `backend` override
-*  (harness + model) wins over the seam default, encoded as `${harness}/${model}`.
-*  Absent an override the seam `model` is used verbatim. */
-function bridgeCellModel(seamModel, ctx) {
+/** Resolve the bridge wire model for this spawn. Per-create matrix settings win, then the
+* canonical profile's harness/model preferences, then the bridge's configured fallback. */
+function bridgeCellModel(seamModel, ctx, profile) {
 	const backend = ctx.seams.createOptions?.backend;
-	const harness = backend?.type;
-	const model = backend?.model?.model;
+	const profileHarness = profile.harness === "cli-base" ? void 0 : profile.harness;
+	const harness = backend?.type ?? profileHarness;
+	const model = backend?.model?.model ?? profile.model?.default;
 	if (!harness && !model) return seamModel;
-	const h = harness ?? "";
-	const m = model ?? seamModel;
-	if (!h) return m;
-	return m.startsWith(`${h}/`) ? m : `${h}/${m}`;
+	if (!harness) return model;
+	if (model) return model.startsWith(`${harness}/`) ? model : `${harness}/${model}`;
+	return seamModel?.startsWith(`${harness}/`) ? seamModel : void 0;
 }
 const bridgeExecutor = (spec, ctx) => {
 	const base = readSeam(ctx, bridgeSeamKey, "bridge");
+	const effectiveProfile = agentProfileSchema.parse(mergeAgentProfiles(spec.profile, base.agentProfile) ?? spec.profile);
 	const seam = {
 		...base,
-		model: bridgeCellModel(base.model, ctx)
+		model: bridgeCellModel(base.model, ctx, effectiveProfile)
 	};
-	if (!seam.bridgeUrl || !seam.bridgeBearer || !seam.model) throw new ValidationError("bridgeExecutor: BridgeSeam.bridgeUrl + bridgeBearer + model required");
+	if (!seam.bridgeUrl || !seam.bridgeBearer || !seam.model) throw new ValidationError("bridgeExecutor: bridgeUrl + bridgeBearer and a profile or bridge model are required");
 	const maxTurns = seam.maxTurns ?? 200;
 	const sessionId = seam.sessionId ?? `bridge-${spec.profile.name ?? "worker"}-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(sessionId);
 	const controller = new AbortController();
 	const abortIfSignalled = () => {
 		if (ctx.signal.aborted) controller.abort();
@@ -3752,27 +4403,31 @@ const bridgeExecutor = (spec, ctx) => {
 	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
 	const inbox = createInbox();
 	let artifact;
-	return {
+	const activeRuns = /* @__PURE__ */ new Map();
+	return attestRuntimeOwnedExecutor({
 		runtime: "cli",
 		deliver: (m) => inbox.deliver(m),
 		execute(task, signal) {
 			return streamBridgeSession({
 				task,
 				signal,
-				spec,
+				profile: effectiveProfile,
 				seam,
 				sessionId,
 				maxTurns,
 				inbox,
 				controller,
+				activeRuns,
 				onArtifact: (a) => {
 					artifact = a;
 				}
 			});
 		},
-		teardown(_grace) {
+		async teardown(grace) {
 			controller.abort();
-			return Promise.resolve({ destroyed: true });
+			const remaining = [...activeRuns.values()].filter((run) => !run.terminal);
+			if (remaining.length === 0) return { destroyed: true };
+			return { destroyed: (await Promise.all(remaining.map((run) => cancelBridgeRunToTerminal(seam, run, grace)))).every(Boolean) };
 		},
 		resultArtifact() {
 			if (!artifact) throw new ValidationError("bridgeExecutor: resultArtifact() read before stream drained");
@@ -3781,7 +4436,40 @@ const bridgeExecutor = (spec, ctx) => {
 				spent: artifact.spent
 			};
 		}
-	};
+	}, {
+		effectiveProfile,
+		backend: "bridge",
+		model: {
+			status: "known",
+			id: seam.model
+		},
+		execution: {
+			kind: "session",
+			id: sessionId
+		},
+		materializer: "cli-bridge-agent-profile",
+		plan: {
+			kind: "cli-bridge-session",
+			cwd: seam.cwd ?? null,
+			maxTurns,
+			timeoutMs: seam.timeoutMs ?? null,
+			streaming: true
+		}
+	}, {
+		attemptId,
+		binding: {
+			bridgeUrl: seam.bridgeUrl,
+			cwd: seam.cwd ?? null,
+			effectiveProfile,
+			model: seam.model,
+			sessionId
+		},
+		descriptor: {
+			kind: "bridge-session",
+			transport: "http",
+			backend: "bridge"
+		}
+	});
 };
 /**
 * One resumable cli-bridge session, run as a streamed turn loop. Turn 0 sends the
@@ -3795,12 +4483,13 @@ async function* streamBridgeSession(args) {
 	const started = Date.now();
 	const external = mergeAbortSignals(args.signal, args.controller.signal);
 	const tokens = zeroTokenUsage();
+	let tokensKnown = true;
 	let usd = 0;
+	let usdKnown = true;
 	let turns = 0;
 	let lastText = "";
 	const toolCalls = [];
 	let nextPrompt = taskToPrompt(args.task);
-	const system = args.spec.profile.prompt?.systemPrompt;
 	for (let t = 0; t < args.maxTurns; t += 1) {
 		const pending = inbox.drain();
 		if (pending.length) {
@@ -3809,10 +4498,6 @@ async function* streamBridgeSession(args) {
 		}
 		if (nextPrompt === void 0) break;
 		const messages = [];
-		if (t === 0 && typeof system === "string" && system.length > 0) messages.push({
-			role: "system",
-			content: system
-		});
 		messages.push({
 			role: "user",
 			content: nextPrompt
@@ -3824,45 +4509,46 @@ async function* streamBridgeSession(args) {
 		if (external.aborted) turnController.abort();
 		else external.addEventListener("abort", abortTurn);
 		interruptSig.addEventListener("abort", abortTurn, { once: true });
-		const timer = seam.timeoutMs ? setTimeout(abortTurn, seam.timeoutMs) : void 0;
+		let timedOut = false;
+		const timer = seam.timeoutMs ? setTimeout(() => {
+			timedOut = true;
+			abortTurn();
+		}, seam.timeoutMs) : void 0;
 		const cleanup = () => {
 			external.removeEventListener("abort", abortTurn);
 			if (timer) clearTimeout(timer);
 		};
-		let res;
-		try {
-			res = await bridgeStreamPost(seam.bridgeUrl, {
-				bearer: seam.bridgeBearer,
-				sessionId: args.sessionId,
-				body: {
-					model: seam.model,
-					stream: true,
-					session_id: args.sessionId,
-					...seam.cwd ? { cwd: seam.cwd } : {},
-					...seam.agentProfile ? { agent_profile: seam.agentProfile } : {},
-					messages
-				},
-				signal: turnController.signal
-			});
-		} catch (e) {
-			cleanup();
-			if (e instanceof DOMException && e.name === "AbortError" && interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted) continue;
-			throw e;
-		}
-		if (!res.ok) {
-			cleanup();
-			throw new ValidationError(`bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`);
-		}
-		if (!res.body) {
-			cleanup();
-			throw new ValidationError("bridgeExecutor: bridge response had no body to stream");
-		}
+		const activeRun = {
+			id: `bridge-run-${randomUUID()}`,
+			lastEventId: 0,
+			terminal: false
+		};
+		args.activeRuns.set(activeRun.id, activeRun);
+		const requestBody = {
+			model: seam.model,
+			stream: true,
+			run_id: activeRun.id,
+			session_id: args.sessionId,
+			...seam.cwd ? { cwd: seam.cwd } : {},
+			agent_profile: args.profile,
+			messages
+		};
 		let turnText = "";
+		let turnTokensKnown = false;
+		let turnUsdKnown = false;
+		let interrupted = false;
 		try {
-			for await (const chunk of parseSseChatStream(res.body)) {
+			for await (const chunk of streamDurableBridgeRun({
+				seam,
+				sessionId: args.sessionId,
+				body: requestBody,
+				signal: turnController.signal,
+				run: activeRun
+			})) {
 				if (chunk.content) turnText += chunk.content;
 				if (chunk.toolCall) toolCalls.push(chunk.toolCall);
 				if (chunk.usage) {
+					turnTokensKnown = true;
 					tokens.input += chunk.usage.input;
 					tokens.output += chunk.usage.output;
 					yield {
@@ -3871,26 +4557,43 @@ async function* streamBridgeSession(args) {
 						output: chunk.usage.output
 					};
 				}
-				if (typeof chunk.cost === "number" && chunk.cost > 0) {
-					usd += chunk.cost;
-					yield {
-						kind: "cost",
-						usd: chunk.cost
-					};
+				if (typeof chunk.cost === "number") {
+					turnUsdKnown = true;
+					if (chunk.cost > 0) {
+						usd += chunk.cost;
+						yield {
+							kind: "cost",
+							usd: chunk.cost
+						};
+					}
 				}
 			}
+		} catch (error) {
+			if (interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted) {
+				if (!await cancelBridgeRunToTerminal(seam, activeRun, "infinity", external)) throw new ValidationError(`bridgeExecutor: interrupted run ${activeRun.id} did not reach terminal state`);
+				interrupted = true;
+			} else {
+				if (timedOut && !activeRun.terminal) await requestBridgeRunCancellation(seam, activeRun, 0);
+				throw error;
+			}
 		} finally {
 			cleanup();
 		}
+		if (interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted) interrupted = true;
 		turns += 1;
+		if (!turnTokensKnown) tokensKnown = false;
+		if (!turnUsdKnown) usdKnown = false;
 		yield { kind: "iteration" };
-		if (turnText) lastText = turnText;
+		if (!interrupted && turnText) lastText = turnText;
+		if (interrupted) continue;
 		if (inbox.pending() === 0) break;
 	}
 	const spent = {
 		iterations: turns,
 		tokens,
+		...tokensKnown ? {} : { tokensKnown: false },
 		usd,
+		...usdKnown ? {} : { usdKnown: false },
 		ms: Date.now() - started
 	};
 	const out = {
@@ -3907,6 +4610,69 @@ async function* streamBridgeSession(args) {
 		spent
 	});
 }
+const BRIDGE_MAX_RECONNECTS = 3;
+const BRIDGE_CANCEL_LONG_POLL_MS = 3e4;
+const BRIDGE_BRUTAL_KILL_WAIT_MS = 150;
+/**
+* Drain one server-owned bridge run. A transport loss replays from the last
+* contiguous event id under the SAME run id and request bytes. No unnumbered,
+* duplicate, or skipped event is accepted: an exact replay contract that
+* cannot prove continuity fails instead of returning a plausible partial answer.
+*/
+async function* streamDurableBridgeRun(args) {
+	let reconnects = 0;
+	let pendingUpstreamError;
+	for (;;) {
+		let res;
+		try {
+			res = await bridgeStreamPost(args.seam.bridgeUrl, {
+				bearer: args.seam.bridgeBearer,
+				sessionId: args.sessionId,
+				runId: args.run.id,
+				afterEventId: args.run.lastEventId,
+				body: args.body,
+				signal: args.signal
+			});
+		} catch (error) {
+			if (args.signal.aborted) throw error;
+			if (reconnects >= BRIDGE_MAX_RECONNECTS) throw new ValidationError(`bridgeExecutor: run ${args.run.id} disconnected before terminal acknowledgement after ${reconnects + 1} attempts: ${errorMessage$1(error)}`);
+			reconnects += 1;
+			continue;
+		}
+		if (!res.ok) throw new ValidationError(`bridgeExecutor: bridge ${res.status}: ${(await res.text()).slice(0, 300)}`);
+		if (!res.body) throw new ValidationError("bridgeExecutor: bridge response had no body to stream");
+		assertBridgeResponseIdentity(res, args.run);
+		let sawDone = false;
+		try {
+			for await (const event of parseSseChatStream(res.body)) {
+				if (event.kind === "done") {
+					sawDone = true;
+					break;
+				}
+				const expected = args.run.lastEventId + 1;
+				if (event.id !== expected) throw new ValidationError(`bridgeExecutor: run ${args.run.id} replay gap: expected event ${expected}, received ${event.id}`);
+				args.run.lastEventId = event.id;
+				if (event.error) pendingUpstreamError = event.error;
+				if (event.chunk) yield event.chunk;
+			}
+		} catch (error) {
+			if (args.signal.aborted) throw error;
+			if (error instanceof ValidationError) throw error;
+			if (reconnects >= BRIDGE_MAX_RECONNECTS) throw new ValidationError(`bridgeExecutor: run ${args.run.id} stream disconnected before terminal acknowledgement after ${reconnects + 1} attempts: ${errorMessage$1(error)}`);
+			reconnects += 1;
+			continue;
+		}
+		if (sawDone) {
+			args.run.terminal = true;
+			if (pendingUpstreamError) throw pendingUpstreamError;
+			return;
+		}
+		if (pendingUpstreamError) throw pendingUpstreamError;
+		if (args.signal.aborted) throw new DOMException("bridgeExecutor: turn aborted", "AbortError");
+		if (reconnects >= BRIDGE_MAX_RECONNECTS) throw new ValidationError(`bridgeExecutor: run ${args.run.id} ended without terminal acknowledgement after ${reconnects + 1} attempts`);
+		reconnects += 1;
+	}
+}
 /**
 * POST one streamed turn to the cli-bridge over the `node:http(s)` core client
 * instead of global `fetch`. The bridge runs a harness CLI and streams SSE only
@@ -3934,15 +4700,22 @@ function bridgeStreamPost(url, args) {
 				"content-type": "application/json",
 				authorization: `Bearer ${args.bearer}`,
 				"x-session-id": args.sessionId,
+				"x-run-id": args.runId,
+				...args.afterEventId > 0 ? { "last-event-id": String(args.afterEventId) } : {},
 				"content-length": Buffer.byteLength(payload)
 			},
 			timeout: 0
 		}, (res) => {
+			response = res;
+			res.once("close", () => args.signal.removeEventListener("abort", onAbort));
 			const status = res.statusCode ?? 0;
+			const ok = status >= 200 && status < 300;
+			const body = Readable.toWeb(res);
 			resolve({
-				ok: status >= 200 && status < 300,
+				ok,
 				status,
-				body: Readable.toWeb(res),
+				headers: res.headers,
+				body,
 				text: async () => {
 					const chunks = [];
 					for await (const c of res) chunks.push(c);
@@ -3950,8 +4723,10 @@ function bridgeStreamPost(url, args) {
 				}
 			});
 		});
+		let response;
 		const onAbort = () => {
 			req.destroy(new DOMException("bridgeExecutor: turn aborted", "AbortError"));
+			if (response && "destroy" in response && typeof response.destroy === "function") response.destroy(new DOMException("bridgeExecutor: turn aborted", "AbortError"));
 		};
 		if (args.signal.aborted) onAbort();
 		else args.signal.addEventListener("abort", onAbort, { once: true });
@@ -3959,16 +4734,109 @@ function bridgeStreamPost(url, args) {
 			args.signal.removeEventListener("abort", onAbort);
 			reject(e);
 		});
-		req.on("close", () => args.signal.removeEventListener("abort", onAbort));
+		req.on("close", () => {
+			if (!response) args.signal.removeEventListener("abort", onAbort);
+		});
 		req.write(payload);
 		req.end();
 	});
 }
+function bridgeHeader(headers, name) {
+	const raw = headers[name.toLowerCase()];
+	if (Array.isArray(raw)) return raw.length === 1 ? raw[0] : void 0;
+	return raw;
+}
+function assertBridgeResponseIdentity(response, run) {
+	assertBridgeIdentityHeaders(response.headers, run);
+}
+function assertBridgeIdentityHeaders(headers, run) {
+	const responseRunId = bridgeHeader(headers, "x-run-id");
+	if (responseRunId !== run.id) throw new ValidationError(`bridgeExecutor: bridge run identity mismatch: expected ${run.id}, received ${responseRunId ?? "missing"}`);
+	const digest = bridgeHeader(headers, "x-run-request-digest");
+	if (!digest || !/^sha256:[a-f0-9]{64}$/u.test(digest)) throw new ValidationError("bridgeExecutor: bridge response omitted a valid request digest");
+	if (run.requestDigest !== void 0 && run.requestDigest !== digest) throw new ValidationError(`bridgeExecutor: bridge request digest changed for run ${run.id}: expected ${run.requestDigest}, received ${digest}`);
+	run.requestDigest = digest;
+}
+/** Explicitly cancel one server-owned run and long-poll for its terminal snapshot. */
+function bridgeCancelPost(seam, run, waitMs) {
+	const target = new URL(`${seam.bridgeUrl.replace(/\/$/, "")}/v1/runs/${encodeURIComponent(run.id)}/cancel`);
+	target.searchParams.set("wait_ms", String(waitMs));
+	const requestFn = target.protocol === "https:" ? request$1 : request;
+	return new Promise((resolve, reject) => {
+		const req = requestFn(target, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${seam.bridgeBearer}`,
+				"x-run-id": run.id,
+				"content-length": "0"
+			},
+			timeout: 0
+		}, (res) => {
+			(async () => {
+				const chunks = [];
+				for await (const chunk of res) chunks.push(Buffer.from(chunk));
+				resolve({
+					status: res.statusCode ?? 0,
+					headers: res.headers,
+					text: Buffer.concat(chunks).toString("utf8")
+				});
+			})().catch(reject);
+		});
+		req.on("error", reject);
+		req.end();
+	});
+}
+async function requestBridgeRunCancellation(seam, run, waitMs) {
+	if (run.terminal) return true;
+	if (run.cancelInFlight) return run.cancelInFlight;
+	const work = (async () => {
+		const response = await bridgeCancelPost(seam, run, waitMs);
+		if (response.status === 404) throw new ValidationError(`bridgeExecutor: bridge no longer knows run ${run.id}; terminal state is unproven`);
+		if (response.status !== 200 && response.status !== 202) throw new ValidationError(`bridgeExecutor: cancel ${run.id} returned ${response.status}: ${response.text.slice(0, 300)}`);
+		assertBridgeIdentityHeaders(response.headers, run);
+		let parsed;
+		try {
+			parsed = JSON.parse(response.text);
+		} catch {
+			throw new ValidationError(`bridgeExecutor: cancel ${run.id} returned invalid JSON`);
+		}
+		if (parsed.run?.id !== run.id || parsed.run.requestDigest !== run.requestDigest || typeof parsed.terminal !== "boolean" || typeof parsed.run.terminal !== "boolean" || parsed.terminal !== parsed.run.terminal) throw new ValidationError(`bridgeExecutor: cancel ${run.id} returned an inconsistent terminal snapshot`);
+		if (response.status === 200 && parsed.terminal === true) {
+			run.terminal = true;
+			return true;
+		}
+		if (response.status === 202 && parsed.terminal === false) return false;
+		throw new ValidationError(`bridgeExecutor: cancel ${run.id} status ${response.status} disagreed with terminal=${String(parsed.terminal)}`);
+	})();
+	run.cancelInFlight = work;
+	try {
+		return await work;
+	} finally {
+		if (run.cancelInFlight === work) run.cancelInFlight = void 0;
+	}
+}
+async function cancelBridgeRunToTerminal(seam, run, grace, stopSignal) {
+	if (run.terminal) return true;
+	const deadline = grace === "infinity" ? void 0 : Date.now() + (grace === "brutalKill" ? BRIDGE_BRUTAL_KILL_WAIT_MS : Math.max(0, grace));
+	let first = true;
+	for (;;) {
+		const remaining = deadline === void 0 ? BRIDGE_CANCEL_LONG_POLL_MS : deadline - Date.now();
+		if (!first && remaining <= 0) return false;
+		if (!first && stopSignal?.aborted) return false;
+		if (await requestBridgeRunCancellation(seam, run, Math.max(0, Math.min(stopSignal ? 1e3 : BRIDGE_CANCEL_LONG_POLL_MS, deadline === void 0 ? remaining : Math.max(0, remaining))))) return true;
+		first = false;
+		if (deadline !== void 0 && Date.now() >= deadline) return false;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 /**
 * Parse cli-bridge's OpenAI-compatible SSE stream into normalized chunks. Each
-* `data:` line is an OpenAI chat-completion chunk (`choices[].delta`); `[DONE]`
-* and SSE comments (`:` keepalives) terminate/skip. Mirrors how `streamSandboxLeaf`
-* folds a box's event stream — same `UsageEvent` currency, different wire shape.
+* `data:` line is an OpenAI chat-completion chunk (`choices[].delta`). Every
+* run-owned frame, including an id-only comment, is returned so the caller can
+* prove a contiguous replay sequence. Transport keepalives have no id and are ignored.
 */
 async function* parseSseChatStream(body) {
 	const reader = body.getReader();
@@ -3979,18 +4847,18 @@ async function* parseSseChatStream(body) {
 			const { done, value } = await reader.read();
 			if (done) break;
 			buf += decoder.decode(value, { stream: true });
-			let sep = buf.indexOf("\n\n");
-			while (sep !== -1) {
-				const frame = buf.slice(0, sep);
-				buf = buf.slice(sep + 2);
-				const chunk = parseSseFrame(frame);
-				if (chunk === "done") return;
-				if (chunk) yield chunk;
-				sep = buf.indexOf("\n\n");
+			let separator = /\r?\n\r?\n/u.exec(buf);
+			while (separator) {
+				const frame = buf.slice(0, separator.index);
+				buf = buf.slice(separator.index + separator[0].length);
+				const event = parseSseFrame(frame);
+				if (event) yield event;
+				separator = /\r?\n\r?\n/u.exec(buf);
 			}
 		}
+		buf += decoder.decode();
 		const tail = parseSseStreamTail(buf);
-		if (tail !== void 0 && tail !== "done") yield tail;
+		if (tail !== void 0) yield tail;
 	} finally {
 		reader.releaseLock();
 	}
@@ -4012,25 +4880,41 @@ function parseSseStreamTail(buf) {
 	}
 	if (parsed.error) throw new ValidationError(`bridgeExecutor: bridge upstream error: ${parsed.error.message ?? parsed.error.type ?? "unknown"}`);
 }
-/** Parse one SSE frame (possibly multi-line `data:`/comment) into a chunk, `'done'`,
-*  or undefined (comment/keepalive/empty). */
+/** Parse one SSE frame into a numbered run event, terminal marker, or unnumbered keepalive. */
 function parseSseFrame(frame) {
 	const dataLines = [];
+	let id;
 	for (const rawLine of frame.split("\n")) {
 		const line = rawLine.replace(/\r$/, "");
 		if (!line || line.startsWith(":")) continue;
+		if (line.startsWith("id:")) {
+			const rawId = line.slice(3).trim();
+			if (!/^[1-9][0-9]*$/u.test(rawId)) throw new ValidationError(`bridgeExecutor: invalid SSE event id ${JSON.stringify(rawId)}`);
+			const parsedId = Number(rawId);
+			if (!Number.isSafeInteger(parsedId)) throw new ValidationError(`bridgeExecutor: SSE event id exceeds safe integer range`);
+			id = parsedId;
+			continue;
+		}
 		if (line.startsWith("data:")) dataLines.push(line.slice(5).trimStart());
 	}
-	if (dataLines.length === 0) return void 0;
+	if (dataLines.length === 0) return id === void 0 ? void 0 : {
+		kind: "event",
+		id
+	};
 	const data = dataLines.join("\n");
-	if (data === "[DONE]") return "done";
+	if (data === "[DONE]") return { kind: "done" };
 	let parsed;
 	try {
 		parsed = JSON.parse(data);
 	} catch {
-		return;
+		throw new ValidationError("bridgeExecutor: bridge emitted a non-JSON SSE data frame");
 	}
-	if (parsed.error) throw new ValidationError(`bridgeExecutor: bridge stream error: ${parsed.error.message ?? parsed.error.type ?? "unknown"}`);
+	if (id === void 0) throw new ValidationError("bridgeExecutor: bridge emitted an unnumbered run event");
+	if (parsed.error) return {
+		kind: "event",
+		id,
+		error: new ValidationError(`bridgeExecutor: bridge stream error: ${parsed.error.message ?? parsed.error.type ?? "unknown"}`)
+	};
 	const out = {};
 	const choice = parsed.choices?.[0];
 	const content = choice?.delta?.content ?? choice?.message?.content;
@@ -4043,7 +4927,11 @@ function parseSseFrame(frame) {
 		output: u.completion_tokens ?? 0
 	};
 	if (typeof u?.cost === "number") out.cost = u.cost;
-	return Object.keys(out).length > 0 ? out : void 0;
+	return {
+		kind: "event",
+		id,
+		...Object.keys(out).length > 0 ? { chunk: out } : {}
+	};
 }
 function bridgeWorktreeExecutor(spec, ctx, seam) {
 	const bridge = seam.bridge;
@@ -4051,6 +4939,9 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 	if (!bridge.bridgeUrl || !bridge.bridgeBearer) throw new ValidationError("cliWorktreeExecutor: bridge.bridgeUrl + bridge.bridgeBearer required");
 	const runId = seam.runId ?? randomUUID();
 	const sessionId = bridge.sessionId ?? `bridge-worktree-${runId}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(runId);
+	const effectiveProfile = agentProfileSchema.parse(mergeAgentProfiles(spec.profile, bridge.agentProfile) ?? spec.profile);
+	const model = bridgeCellModel(bridge.model, ctx, effectiveProfile);
 	const controller = new AbortController();
 	const pending = [];
 	let inner;
@@ -4075,11 +4966,11 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 		}
 		pending.push(msg);
 	};
-	return {
+	return attestRuntimeOwnedExecutor({
 		runtime: "cli",
 		budgetExempt: seam.budgetExempt ?? false,
 		deliver,
-		execute(_task, signal) {
+		execute(task, signal) {
 			return (async function* bridgeWorktreeStream() {
 				const started = Date.now();
 				const linked = mergeAbortSignals(signal, controller.signal);
@@ -4095,10 +4986,10 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 					const bridgeSeam = {
 						bridgeUrl: bridge.bridgeUrl,
 						bridgeBearer: bridge.bridgeBearer,
-						model: resolveBridgeWorktreeModel(spec, bridge),
 						cwd: worktree.path,
 						sessionId,
-						...bridge.agentProfile ? { agentProfile: bridge.agentProfile } : { agentProfile: spec.profile },
+						...bridge.model ? { model: bridge.model } : {},
+						...bridge.agentProfile ? { agentProfile: bridge.agentProfile } : {},
 						...bridge.timeoutMs !== void 0 ? { timeoutMs: bridge.timeoutMs } : {},
 						...bridge.maxTurns !== void 0 ? { maxTurns: bridge.maxTurns } : {}
 					};
@@ -4112,8 +5003,8 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 					};
 					inner = bridgeExecutor(spec, bridgeCtx);
 					for (const msg of pending.splice(0)) inner.deliver?.(msg);
-					const run = inner.execute(seam.taskPrompt, linked);
-					if (isAsyncIterable(run)) {
+					const run = inner.execute(task, linked);
+					if (isAsyncIterable$1(run)) {
 						for await (const event of run) yield event;
 						bridgeArtifact = inner.resultArtifact();
 					} else bridgeArtifact = await run;
@@ -4179,13 +5070,48 @@ function bridgeWorktreeExecutor(spec, ctx, seam) {
 			if (!artifact) throw new ValidationError("cliWorktreeExecutor: bridge resultArtifact() read before stream drained");
 			return artifact;
 		}
-	};
-}
-function resolveBridgeWorktreeModel(spec, bridge) {
-	if (bridge.model) return bridge.model;
-	const model = spec.profile.model?.default;
-	if (typeof model === "string" && model.length > 0) return model;
-	throw new ValidationError("cliWorktreeExecutor: bridge.model or AgentProfile.model.default required");
+	}, {
+		effectiveProfile,
+		backend: "bridge-worktree",
+		model: model ? {
+			status: "known",
+			id: model
+		} : {
+			status: "unknown",
+			reason: "bridge worktree profile did not select a model"
+		},
+		execution: {
+			kind: "worktree-session",
+			id: `${runId}:${sessionId}`
+		},
+		materializer: "bridge-worktree-agent-profile",
+		plan: {
+			kind: "bridge-worktree-session",
+			runId,
+			sessionId,
+			baseRef: seam.baseRef ?? "HEAD",
+			model: model ?? null,
+			testCmd: seam.testCmd ?? null,
+			typecheckCmd: seam.typecheckCmd ?? null,
+			checkTimeoutMs: seam.checkTimeoutMs ?? seam.harnessTimeoutMs ?? bridge.timeoutMs ?? 300 * 1e3,
+			checkOutputCap: seam.checkOutputCap ?? 16e3
+		}
+	}, {
+		attemptId,
+		binding: {
+			bridgeUrl: bridge.bridgeUrl,
+			effectiveProfile,
+			model: model ?? null,
+			repoRoot: seam.repoRoot,
+			runId,
+			sessionId
+		},
+		descriptor: {
+			kind: "bridge-worktree-session",
+			transport: "http",
+			backend: "bridge-worktree"
+		}
+	});
 }
 function bridgeOutputText(out) {
 	if (typeof out === "string") return out;
@@ -4199,7 +5125,7 @@ function bridgeOutputText(out) {
 		return String(out);
 	}
 }
-function isAsyncIterable(value) {
+function isAsyncIterable$1(value) {
 	return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
 }
 /**
@@ -4209,14 +5135,14 @@ function isAsyncIterable(value) {
 */
 const cliWorktreeExecutor = (spec, ctx) => {
 	const seam = readSeam(ctx, cliWorktreeSeamKey, "cli-worktree");
-	if (!seam.repoRoot || !seam.taskPrompt) throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.repoRoot + taskPrompt required");
+	if (!seam.repoRoot) throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.repoRoot required");
 	if (seam.bridge) return bridgeWorktreeExecutor(spec, ctx, seam);
 	if (!seam.harness) throw new ValidationError("cliWorktreeExecutor: CliWorktreeSeam.harness required when bridge is not set");
 	return createWorktreeCliExecutor({
 		repoRoot: seam.repoRoot,
 		profile: spec.profile,
 		harness: seam.harness,
-		taskPrompt: seam.taskPrompt,
+		...seam.taskPrompt !== void 0 ? { taskPrompt: seam.taskPrompt } : {},
 		...seam.runId ? { runId: seam.runId } : {},
 		...seam.baseRef ? { baseRef: seam.baseRef } : {},
 		...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {},
@@ -4228,9 +5154,110 @@ const cliWorktreeExecutor = (spec, ctx) => {
 		...seam.checkOutputCap !== void 0 ? { checkOutputCap: seam.checkOutputCap } : {},
 		...seam.runGit ? { runGit: seam.runGit } : {},
 		...seam.runCommand ? { runCommand: seam.runCommand } : {},
-		...seam.budgetExempt !== void 0 ? { budgetExempt: seam.budgetExempt } : {}
+		...seam.budgetExempt !== void 0 ? { budgetExempt: seam.budgetExempt } : {},
+		...ctx.node?.attemptId !== void 0 ? { executionAttemptId: ctx.node.attemptId } : {}
 	});
 };
+/** Capture one public executor configuration at its call boundary. All data that selects policy,
+* model, process, limits, profile overlays, or backend behavior is detached and deeply frozen.
+* Explicit service/function fields remain live by reference because they are executable ports,
+* not portable configuration. */
+function snapshotExecutorConfig(config) {
+	switch (config.backend) {
+		case "router-tools": {
+			const { executeToolCall, onToolStep, ...decisionData } = config;
+			const snapshot = detachedSnapshot(decisionData, "createExecutor router-tools config");
+			return Object.freeze({
+				...snapshot,
+				executeToolCall,
+				...onToolStep === void 0 ? {} : { onToolStep }
+			});
+		}
+		case "cli-worktree": {
+			const { runGit, runCommand, ...decisionData } = config;
+			const snapshot = detachedSnapshot(decisionData, "createExecutor cli-worktree config");
+			return Object.freeze({
+				...snapshot,
+				...runGit === void 0 ? {} : { runGit },
+				...runCommand === void 0 ? {} : { runCommand }
+			});
+		}
+		case "provider": {
+			const { provider, registry, taskToTurn, ...decisionData } = config;
+			const snapshot = detachedSnapshot(decisionData, "createExecutor provider config");
+			const resolvedProvider = resolveAgentEnvironmentProvider(provider, registry);
+			return Object.freeze({
+				...snapshot,
+				provider: resolvedProvider,
+				...taskToTurn === void 0 ? {} : { taskToTurn }
+			});
+		}
+		case "sandbox": {
+			const { sandboxClient, loopCtx, ...decisionData } = config;
+			if (loopCtx === void 0) {
+				const snapshot = detachedSnapshot(decisionData, "createExecutor sandbox config");
+				return Object.freeze({
+					...snapshot,
+					sandboxClient
+				});
+			}
+			const { hooks, traceEmitter, onSandboxEvent, runHandle, ...loopDecisionData } = loopCtx;
+			const snapshot = detachedSnapshot({
+				...decisionData,
+				loopCtx: loopDecisionData
+			}, "createExecutor sandbox config");
+			const loopSnapshot = snapshot.loopCtx;
+			return Object.freeze({
+				...snapshot,
+				sandboxClient,
+				loopCtx: Object.freeze({
+					...loopSnapshot,
+					...hooks === void 0 ? {} : { hooks },
+					...traceEmitter === void 0 ? {} : { traceEmitter },
+					...onSandboxEvent === void 0 ? {} : { onSandboxEvent },
+					...runHandle === void 0 ? {} : { runHandle }
+				})
+			});
+		}
+		case "router":
+		case "bridge":
+		case "cli":
+		case "pi": return detachedSnapshot(config, `createExecutor ${config.backend} config`);
+	}
+}
+/** A backend config reused for multiple workers/managers cannot pin execution identity or carry a
+* profile overlay applied after Scope hashed the authored profile. Direct single-execution
+* `createExecutor` calls may still use those fields. */
+function captureReusableExecutorConfig(config, context) {
+	const captured = snapshotExecutorConfig(config);
+	if ((captured.backend === "bridge" ? captured.agentProfile : captured.backend === "cli-worktree" ? captured.bridge?.agentProfile : void 0) !== void 0) throw new ValidationError(`${context}: backend agentProfile overlays are not allowed because they change the effective profile after spawn identity is fixed`);
+	const fixedIdentity = captured.backend === "bridge" && captured.sessionId !== void 0 ? "sessionId" : captured.backend === "cli-worktree" && captured.runId !== void 0 ? "runId" : captured.backend === "cli-worktree" && captured.bridge?.sessionId !== void 0 ? "bridge.sessionId" : void 0;
+	if (fixedIdentity !== void 0) throw new ValidationError(`${context}: fixed ${fixedIdentity} is not allowed on a reusable backend; let each execution derive an isolated id`);
+	return captured;
+}
+/** Bind one already-captured reusable backend to the durable identity of the execution that will
+* use it. Stateful bridge backends need an explicit external id: a random default isolates two
+* siblings but cannot reconnect a replacement process to the same harness session. Non-stateful
+* backends carry no external execution id and are returned unchanged. */
+function bindReusableExecutorExecutionId(captured, executionId) {
+	if (typeof executionId !== "string" || executionId.length === 0) throw new ValidationError("bindReusableExecutorExecutionId: executionId must be a non-empty string");
+	switch (captured.backend) {
+		case "bridge": return Object.freeze({
+			...captured,
+			sessionId: executionId
+		});
+		case "cli-worktree": return Object.freeze({
+			...captured,
+			runId: executionId
+		});
+		case "router":
+		case "router-tools":
+		case "cli":
+		case "provider":
+		case "pi":
+		case "sandbox": return captured;
+	}
+}
 /**
 * The single built-in executor factory. Picks a leaf backend by data (`config.backend`),
 * injects the matching seam, and delegates to that backend's built-in implementation.
@@ -4240,8 +5267,10 @@ const cliWorktreeExecutor = (spec, ctx) => {
 * `UsageEvent` reporting channel.
 */
 function createExecutor(config) {
+	const captured = snapshotExecutorConfig(config);
 	return (spec, ctx) => {
-		const { backend, ...seam } = config;
+		const { backend, ...seamData } = captured;
+		const seam = Object.freeze(seamData);
 		const seamed = {
 			...ctx,
 			seams: {
@@ -4249,7 +5278,7 @@ function createExecutor(config) {
 				[backend]: seam
 			}
 		};
-		switch (config.backend) {
+		switch (captured.backend) {
 			case "router": return routerInlineExecutor(spec, seamed);
 			case "router-tools": return routerToolsInlineExecutor(spec, seamed);
 			case "bridge": return bridgeExecutor(spec, seamed);
@@ -4258,10 +5287,41 @@ function createExecutor(config) {
 			case "pi": return piExecutor(spec, seamed);
 			case "provider": {
 				const providerSeam = readSeam(seamed, providerSeamKey, "provider");
-				return providerAsExecutor(resolveAgentEnvironmentProvider(providerSeam.provider, providerSeam.registry), providerSeam)(spec, seamed);
+				const provider = resolveAgentEnvironmentProvider(providerSeam.provider, providerSeam.registry);
+				if (providerSeam.steering) {
+					if (providerSeam.taskToTurn) throw new ValidationError("createExecutor(provider, steering): taskToTurn is not representable by the text-only steerable session");
+					if (providerSeam.destroyOnSettle === false) throw new ValidationError("createExecutor(provider, steering): destroyOnSettle=false conflicts with the session-owned environment lifecycle");
+					const harness = requiredProviderProfileHarness(spec, providerSeam);
+					const sandboxClient = providerAsSandboxClient(provider, {
+						defaults: {
+							...providerSeam.defaults ?? {},
+							signal: seamed.signal
+						},
+						requireTerminalEvent: providerSeam.requireTerminalEvent,
+						requireSession: true
+					});
+					const providerCtx = {
+						...seamed,
+						seams: {
+							...seamed.seams,
+							[sandboxSeamKey]: {
+								sandboxClient,
+								steering: providerSeam.steering
+							}
+						}
+					};
+					return {
+						...sandboxExecutor({
+							...spec,
+							harness
+						}, providerCtx),
+						runtime: providerSeam.runtime ?? provider.name
+					};
+				}
+				return providerAsExecutor(provider, providerSeam)(spec, seamed);
 			}
 			case "sandbox": {
-				const harness = spec.harness ?? config.harness ?? null;
+				const harness = spec.harness ?? captured.harness ?? null;
 				return sandboxExecutor({
 					...spec,
 					harness
@@ -4270,6 +5330,13 @@ function createExecutor(config) {
 		}
 	};
 }
+function requiredProviderProfileHarness(spec, seam) {
+	const harness = spec.profile.harness;
+	if (harness === void 0) throw new ValidationError("createExecutor(provider, steering): AgentProfile.harness is required");
+	if (spec.harness != null && spec.harness !== harness) throw new ValidationError(`createExecutor(provider, steering): AgentSpec.harness "${spec.harness}" conflicts with AgentProfile.harness "${harness}"`);
+	if (seam.defaults?.backend !== void 0 && seam.defaults.backend !== harness) throw new ValidationError(`createExecutor(provider, steering): provider default backend "${seam.defaults.backend}" conflicts with AgentProfile.harness "${harness}"`);
+	return harness;
+}
 /**
 * The open resolver/registry. Pre-registers the three built-ins under their
 * runtime tags (`'router'`, `'sandbox'`, `'cli'`) and accepts `register(name,
@@ -4277,8 +5344,8 @@ function createExecutor(config) {
 * without touching the registry at all. NOT a closed switch; registration + BYO
 * ARE the extension points.
 *
-* `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →
-* `harness === null` → the `'router'` factory; else a registered factory for the
+* `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executorFactory` →
+* `spec.executor` → `harness === null` → the `'router'` factory; else a registered factory for the
 * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.
 */
 function createExecutorRegistry() {
@@ -4294,6 +5361,10 @@ function createExecutorRegistry() {
 			factories.set(runtime, factory);
 		},
 		resolve(spec) {
+			if (spec.executorFactory) return {
+				succeeded: true,
+				value: spec.executorFactory
+			};
 			if (spec.executor) {
 				const byo = spec.executor;
 				return {
@@ -4347,11 +5418,11 @@ function taskToPrompt(task) {
 	}
 	return JSON.stringify(task);
 }
-/** Router messages from the opaque task + the profile's system prompt, when set. */
+/** Router messages from the opaque task + every portable profile prompt instruction. */
 function taskToMessages(task, spec) {
 	const messages = [];
-	const system = spec.profile.prompt?.systemPrompt;
-	if (typeof system === "string" && system.length > 0) messages.push({
+	const system = [spec.profile.prompt?.systemPrompt, ...spec.profile.prompt?.instructions ?? []].filter((line) => typeof line === "string" && line.trim().length > 0).join("\n");
+	if (system.length > 0) messages.push({
 		role: "system",
 		content: system
 	});
@@ -4449,8 +5520,9 @@ function createInMemoryRunContext(opts = {}) {
 * back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
 *
 * Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event), `${dir}/blobs/` (one
-* content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl` (questions
-* + findings, replayed into a resumed driver). The directory is created on first write.
+* content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl`
+* (questions, findings, answer decisions, and authorized continuation receipts retained as
+* evidence). The directory is created on first write.
 *
 * Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
 * existing consumer writes to disk or resumes unless it asks for this.
@@ -4508,168 +5580,6 @@ function watchTrace(source, opts = {}) {
 	});
 }
 //#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. `CoordinationToolsOptions.maxLiveWorkers` (`src/mcp/tools/coordination.ts`) — supervisor
-*      level. How many workers may be spawned-but-not-settled at once; `spawn_agent` fails closed
-*      with `error: 'max-live-workers'` past it. Unset by default ⇒ NO cap at this layer.
-*   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/event-bus.ts
 /** Create the child→parent coordination bus: one typed pipe for settled outputs, questions, and analyst findings, with a priority-ordered pull queue and a pass-through subscribe lane. */
 function createEventBus(now = Date.now) {
@@ -4677,7 +5587,9 @@ function createEventBus(now = Date.now) {
 	const log = [];
 	const subscribers = [];
 	const byKind = {};
+	const staged = /* @__PURE__ */ new WeakMap();
 	let seq = 0;
+	let published = 0;
 	let pulled = 0;
 	const matches = (r, kinds) => !kinds || kinds.includes(r.event.type);
 	const bestIndex = (kinds) => {
@@ -4695,16 +5607,19 @@ function createEventBus(now = Date.now) {
 	};
 	return {
 		async publish(event, opts) {
-			const record = {
+			const record = staged.get(event) ?? {
 				seq: seq++,
 				at: now(),
 				priority: opts?.priority ?? 0,
 				event
 			};
+			staged.set(event, record);
+			for (const handler of subscribers) await handler(record);
+			staged.delete(event);
 			if (opts?.queue !== false) queue.push(record);
 			log.push(record);
+			published += 1;
 			byKind[event.type] = (byKind[event.type] ?? 0) + 1;
-			for (const handler of subscribers) await handler(record);
 			return record;
 		},
 		pull(kinds) {
@@ -4728,7 +5643,7 @@ function createEventBus(now = Date.now) {
 		},
 		stats() {
 			return {
-				published: seq,
+				published,
 				pulled,
 				byKind: { ...byKind }
 			};
@@ -4936,14 +5851,6 @@ function spawnProfileArg() {
 	}).properties));
 	return spawnProfileArgCache;
 }
-/** Freeze a JSON-Schema tree. The derived schema is plain JSON data with no cycles. */
-function deepFreeze(value) {
-	if (value && typeof value === "object" && !Object.isFrozen(value)) {
-		Object.freeze(value);
-		for (const nested of Object.values(value)) deepFreeze(nested);
-	}
-	return value;
-}
 /** Build the driver's MCP tools over a live scope. */
 function createCoordinationTools(opts) {
 	const deliverable = opts.deliverable;
@@ -4956,23 +5863,76 @@ function createCoordinationTools(opts) {
 	const questionPolicy = opts.questionPolicy ?? "auto";
 	const completedKeys = /* @__PURE__ */ new Set();
 	const keyByWorker = /* @__PURE__ */ new Map();
+	let unkeyedAssignmentOrdinal = nextUnkeyedAssignmentOrdinal(opts.scope);
 	for (const [key, prior] of opts.scope.resume?.keys ?? []) if (prior.state === "completed") completedKeys.add(key);
-	for (const s of opts.scope.resume?.settled ?? []) ledger.push(s.kind === "done" ? {
-		id: s.handle.id,
-		status: "done",
-		score: s.verdict?.score ?? 0,
-		valid: s.verdict?.valid ?? false,
-		outRef: s.outRef
-	} : {
-		id: s.handle.id,
-		status: "down",
-		reason: s.reason
-	});
+	const nodeForWorker = (id) => opts.scope.view.nodes.find((node) => node.id === id) ?? opts.scope.resume?.view.nodes.find((node) => node.id === id);
+	const projectSettled = (settled, resumed = false) => {
+		const node = nodeForWorker(settled.handle.id);
+		const assignmentId = settled.handle.assignmentId ?? node?.assignmentId;
+		const identity = settled.handle.identity ?? node?.identity;
+		const materialization = settled.handle.materialization ?? node?.materialization;
+		const executionBindings = settled.handle.executionBindings ?? node?.executionBindings;
+		const settledAt = settled.settledAt ?? node?.settledAt;
+		const trace = settled.trace ?? node?.trace ?? {
+			status: "unavailable",
+			reason: "legacy-settlement-without-trace-evidence"
+		};
+		const common = {
+			id: settled.handle.id,
+			...assignmentId === void 0 ? {} : { assignmentId },
+			...identity === void 0 ? {} : { identity },
+			...materialization === void 0 ? {} : { materialization },
+			...executionBindings === void 0 ? {} : { executionBindings },
+			...settledAt === void 0 ? {} : { settledAt },
+			trace,
+			...resumed ? { resumed: true } : {}
+		};
+		return deepFreezeDetached(settled.kind === "done" ? {
+			...common,
+			status: "done",
+			spent: settled.spent,
+			...settled.verdict?.score === void 0 ? {} : { score: settled.verdict.score },
+			...settled.verdict?.valid === void 0 ? {} : { valid: settled.verdict.valid },
+			outRef: settled.outRef
+		} : {
+			...common,
+			status: "down",
+			...node?.spent === void 0 ? {} : { spent: node.spent },
+			reason: settled.reason
+		});
+	};
+	const resumedWorkers = [];
+	for (const s of opts.scope.resume?.settled ?? []) {
+		const worker = projectSettled(s, true);
+		resumedWorkers.push(worker);
+		ledger.push(worker);
+	}
 	const bus = createEventBus();
 	if (opts.onEvent) {
 		const cb = opts.onEvent;
-		bus.subscribe((rec) => cb(rec.event));
-	}
+		bus.subscribe((rec) => cb(rec.event, rec));
+	}
+	const resumeEvents = opts.replaySettlements ? resumedWorkers.map((worker) => deepFreezeDetached({
+		type: "settled",
+		worker
+	})) : [];
+	let resumeEventIndex = 0;
+	let readyInFlight;
+	const ready = () => {
+		if (resumeEventIndex >= resumeEvents.length) return Promise.resolve();
+		if (readyInFlight) return readyInFlight;
+		readyInFlight = (async () => {
+			while (resumeEventIndex < resumeEvents.length) {
+				const event = resumeEvents[resumeEventIndex];
+				if (!event) break;
+				await bus.publish(event);
+				resumeEventIndex += 1;
+			}
+		})().finally(() => {
+			readyInFlight = void 0;
+		});
+		return readyInFlight;
+	};
 	const urgencyPriority = (u) => u === "blocks-run" ? 20 : u === "blocks-step" ? 10 : 0;
 	const str = (v, field) => {
 		if (typeof v !== "string" || v.length === 0) throw new Error(`coordination tools: "${field}" must be a non-empty string`);
@@ -4995,12 +5955,14 @@ function createCoordinationTools(opts) {
 		const maxTokens = field("maxTokens");
 		const maxUsd = field("maxUsd");
 		const deadlineMs = field("deadlineMs");
-		return {
+		const merged = {
 			maxIterations: maxIterations ?? base.maxIterations,
 			maxTokens: maxTokens ?? base.maxTokens,
 			...(maxUsd ?? base.maxUsd) === void 0 ? {} : { maxUsd: maxUsd ?? base.maxUsd },
 			...(deadlineMs ?? base.deadlineMs) === void 0 ? {} : { deadlineMs: deadlineMs ?? base.deadlineMs }
 		};
+		assertValidBudget(merged, "coordination tools: budget");
+		return merged;
 	};
 	const level = (v) => {
 		if (v === "worker" || v === "driver" || v === "loop") return v;
@@ -5010,43 +5972,27 @@ function createCoordinationTools(opts) {
 		if (v === "continue-without" || v === "blocks-step" || v === "blocks-run") return v;
 		throw new Error("coordination tools: \"urgency\" must be continue-without, blocks-step, or blocks-run");
 	};
-	const recordSettled = (s) => {
-		const settledAt = Date.now();
+	const commitSettled = (s, w) => {
 		const settledKey = keyByWorker.get(s.handle.id);
 		if (settledKey !== void 0 && s.kind === "done") completedKeys.add(settledKey);
-		const w = s.kind === "done" ? {
-			id: s.handle.id,
-			status: "done",
-			score: s.verdict?.score ?? 0,
-			valid: s.verdict?.valid ?? false,
-			outRef: s.outRef,
-			settledAt
-		} : {
-			id: s.handle.id,
-			status: "down",
-			reason: s.reason,
-			settledAt
-		};
 		ledger.push(w);
 		unwatchWorker(w.id);
-		return w;
 	};
-	const drainSettlement = async () => {
-		const s = await opts.scope.next();
-		if (!s) return false;
-		const w = recordSettled(s);
-		await bus.publish({
-			type: "settled",
-			worker: w
-		});
-		if (w.status === "done" && w.outRef && opts.analysts && opts.analyzeOnSettle?.length) {
-			const trace = await opts.blobs.get(w.outRef);
+	let pendingSettlement;
+	const flushPendingSettlement = async () => {
+		const pending = pendingSettlement;
+		if (!pending) return false;
+		await bus.publish(pending.event);
+		commitSettled(pending.settled, pending.worker);
+		pendingSettlement = void 0;
+		if (pending.analyze && pending.worker.status === "done" && pending.worker.trace.status === "available" && opts.analysts && opts.analyzeOnSettle?.length) {
+			const trace = await workerTraceAnalysisStore(pending.worker.trace, opts.blobs);
 			for (const analyst of opts.analyzeOnSettle) {
 				const findings = await opts.analysts.run(analyst, trace);
 				await bus.publish({
 					type: "finding",
 					finding: {
-						fromWorker: w.id,
+						fromWorker: pending.worker.id,
 						analyst,
 						findings
 					}
@@ -5055,16 +6001,41 @@ function createCoordinationTools(opts) {
 		}
 		return true;
 	};
+	const drainSettlement = async () => {
+		if (!pendingSettlement) {
+			const settled = await opts.scope.next();
+			if (!settled) return false;
+			const worker = projectSettled(settled);
+			pendingSettlement = {
+				settled,
+				worker,
+				event: deepFreezeDetached({
+					type: "settled",
+					worker
+				}),
+				analyze: true
+			};
+		}
+		return flushPendingSettlement();
+	};
 	const drainResolved = async () => {
 		let drained = 0;
 		for (;;) {
-			const s = await opts.scope.nextResolved();
-			if (!s) return drained;
-			const w = recordSettled(s);
-			await bus.publish({
-				type: "settled",
-				worker: w
-			});
+			if (!pendingSettlement) {
+				const settled = await opts.scope.nextResolved();
+				if (!settled) return drained;
+				const worker = projectSettled(settled);
+				pendingSettlement = {
+					settled,
+					worker,
+					event: deepFreezeDetached({
+						type: "settled",
+						worker
+					}),
+					analyze: false
+				};
+			}
+			await flushPendingSettlement();
 			drained += 1;
 		}
 	};
@@ -5078,21 +6049,100 @@ function createCoordinationTools(opts) {
 			down
 		}, { queue: false });
 	}
+	const authorizeInstruction = (kind, workerId, instruction, interrupt, questionId) => {
+		const workerIdentity = opts.scope.view.nodes.find((node) => node.id === workerId)?.identity;
+		let authorizedInstruction = instruction;
+		if (opts.authorizeDownMessage) {
+			if (workerIdentity === void 0) throw new Error(`coordination tools: cannot authorize ${kind} for worker ${JSON.stringify(workerId)} without durable identity`);
+			const decision = deepFreezeDetached(opts.authorizeDownMessage(deepFreezeDetached({
+				kind,
+				workerId,
+				workerIdentity,
+				instruction,
+				interrupt,
+				...questionId !== void 0 ? { questionId } : {}
+			})));
+			if (typeof decision !== "object" || decision === null || Array.isArray(decision) || typeof decision.instruction !== "string" || decision.instruction.length === 0) throw new Error("coordination tools: authorizeDownMessage must return an instruction");
+			authorizedInstruction = decision.instruction;
+		}
+		return deepFreezeDetached({
+			receiptId: randomUUID(),
+			kind,
+			toWorker: workerId,
+			instruction: authorizedInstruction,
+			instructionDigest: canonicalCandidateDigest(authorizedInstruction),
+			...workerIdentity !== void 0 ? { workerIdentity } : {},
+			interrupt,
+			...questionId !== void 0 ? { questionId } : {}
+		});
+	};
+	/** Publish before `scope.send`: an awaited durable subscriber therefore commits the exact bytes
+	* before the worker can observe them. */
+	const recordInstruction = async (instruction) => {
+		await bus.publish({
+			type: "instruction",
+			instruction
+		}, { queue: false });
+	};
+	/** Commit delivery intent after the authorization receipt and before `Scope.send`. An attempt with
+	* no matching outcome after a crash is explicitly unknown and must never be replayed. */
+	const recordDeliveryAttempt = async (instruction) => {
+		const attempt = deepFreezeDetached({
+			receiptId: instruction.receiptId,
+			kind: instruction.kind,
+			toWorker: instruction.toWorker,
+			instructionDigest: instruction.instructionDigest,
+			interrupt: instruction.interrupt,
+			...instruction.questionId !== void 0 ? { questionId: instruction.questionId } : {}
+		});
+		await bus.publish({
+			type: "delivery-attempt",
+			attempt
+		}, { queue: false });
+		return attempt;
+	};
+	const deliveryOutcome = (workerId, delivered) => {
+		if (delivered) return "delivered";
+		if (opts.scope.signal.aborted) return "scope-stopped";
+		const node = opts.scope.view.nodes.find((candidate) => candidate.id === workerId);
+		if (!node) return "unknown-worker";
+		if (!isLive(node.status)) return "already-settled";
+		return "runtime-has-no-inbox";
+	};
+	const attemptDelivery = async (instruction, message) => {
+		await recordDeliveryAttempt(instruction);
+		let delivered = false;
+		let outcome;
+		let error;
+		try {
+			delivered = opts.scope.send(instruction.toWorker, message);
+			outcome = deliveryOutcome(instruction.toWorker, delivered);
+		} catch (cause) {
+			outcome = "runtime-error";
+			error = cause instanceof Error ? cause.message : String(cause);
+		}
+		const down = deepFreezeDetached({
+			receiptId: instruction.receiptId,
+			toWorker: instruction.toWorker,
+			instruction: instruction.instruction,
+			instructionDigest: instruction.instructionDigest,
+			delivered,
+			outcome,
+			...error !== void 0 ? { error } : {}
+		});
+		if (instruction.kind === "answer") await sendDown("answer", down, str(instruction.questionId, "questionId"));
+		else await sendDown("steer", down);
+		if (error !== void 0) throw new Error(`coordination tools: delivery failed: ${error}`);
+		return down;
+	};
 	const projectEvent = (ev) => {
 		if (ev.type === "settled") {
-			const w = ev.worker;
-			return w.status === "done" ? {
-				type: "settled",
-				settled: w.id,
-				status: "done",
-				score: w.score,
-				valid: w.valid,
-				outRef: w.outRef
-			} : {
+			const { id, status, ...evidence } = ev.worker;
+			return {
 				type: "settled",
-				settled: w.id,
-				status: "down",
-				reason: w.reason
+				settled: id,
+				status,
+				...evidence
 			};
 		}
 		if (ev.type === "question") return {
@@ -5108,12 +6158,25 @@ function createCoordinationTools(opts) {
 			...ev.down,
 			questionId: ev.questionId
 		};
-		return {
+		if (ev.type === "instruction") return {
+			type: "instruction",
+			...ev.instruction
+		};
+		if (ev.type === "delivery-attempt") return {
+			type: "delivery-attempt",
+			...ev.attempt
+		};
+		return {
 			type: ev.type,
 			...ev.down
 		};
 	};
-	const nextQuestionId = (from) => `${from}:q${questionSeq++}`;
+	const nextQuestionId = (from) => {
+		for (;;) {
+			const id = `${from}:q${questionSeq++}`;
+			if (!questions.some((question) => question.id === id)) return id;
+		}
+	};
 	const normalizeQuestion = (q, fallbackFrom) => {
 		const from = str(q.from ?? fallbackFrom, "from");
 		return {
@@ -5181,13 +6244,30 @@ function createCoordinationTools(opts) {
 	};
 	const maxLiveWorkers = opts.maxLiveWorkers;
 	const isLive = (status) => status !== "done" && status !== "failed" && status !== "cancelled";
-	const liveWorkerCount = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).length;
-	const liveSnapshot = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).map((n) => ({
-		id: n.id,
-		status: n.status,
-		spent: n.spent
-	}));
-	const freeWorkerSlots = () => freeSlots(liveWorkerCount(), maxLiveWorkers);
+	const localLiveWorkerCount = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).length;
+	const sharedWorkerCapacity = () => {
+		return opts.scope.workerCapacity;
+	};
+	const usesTreeWideLimit = () => {
+		const capacity = sharedWorkerCapacity();
+		return capacity !== void 0 && capacity.freeSlots !== null;
+	};
+	const liveWorkerCount = () => usesTreeWideLimit() ? sharedWorkerCapacity()?.live ?? localLiveWorkerCount() : localLiveWorkerCount();
+	const projectNodeEvidence = (node, resumed = false) => ({
+		id: node.id,
+		status: node.status,
+		...node.assignmentId === void 0 ? {} : { assignmentId: node.assignmentId },
+		...node.identity === void 0 ? {} : { identity: node.identity },
+		...node.materialization === void 0 ? {} : { materialization: node.materialization },
+		...node.executionBindings === void 0 ? {} : { executionBindings: node.executionBindings },
+		spent: node.spent,
+		...node.settledAt === void 0 ? {} : { settledAt: node.settledAt },
+		...node.outRef === void 0 ? {} : { outRef: node.outRef },
+		...node.trace === void 0 ? {} : { trace: node.trace },
+		...resumed ? { resumed: true } : {}
+	});
+	const liveSnapshot = () => opts.scope.view.nodes.filter((n) => isLive(n.status)).map((n) => projectNodeEvidence(n));
+	const freeWorkerSlots = () => usesTreeWideLimit() ? sharedWorkerCapacity()?.freeSlots ?? null : freeSlots(localLiveWorkerCount(), maxLiveWorkers);
 	const readProgress = (id) => {
 		const scope = opts.scope;
 		if (typeof scope.progress !== "function") return void 0;
@@ -5288,10 +6368,22 @@ function createCoordinationTools(opts) {
 						type: "object",
 						description: "Optional per-spawn budget that merges over the per-worker default (per field). Only set the ceilings this sub-task needs raised; the conserved pool still fences.",
 						properties: {
-							maxIterations: { type: "number" },
-							maxTokens: { type: "number" },
-							maxUsd: { type: "number" },
-							deadlineMs: { type: "number" }
+							maxIterations: {
+								type: "number",
+								minimum: 0
+							},
+							maxTokens: {
+								type: "number",
+								minimum: 0
+							},
+							maxUsd: {
+								type: "number",
+								minimum: 0
+							},
+							deadlineMs: {
+								type: "number",
+								minimum: 0
+							}
 						}
 					}
 				},
@@ -5300,28 +6392,47 @@ function createCoordinationTools(opts) {
 			handler: (raw) => {
 				const a = obj(raw);
 				const key = a.key === void 0 ? void 0 : str(a.key, "key");
-				if (!(key !== void 0 && completedKeys.has(key)) && maxLiveWorkers !== void 0 && maxLiveWorkers > 0 && liveWorkerCount() >= maxLiveWorkers) return Promise.resolve({
+				if (!(key !== void 0 && completedKeys.has(key)) && !usesTreeWideLimit() && maxLiveWorkers !== void 0 && maxLiveWorkers > 0 && liveWorkerCount() >= maxLiveWorkers) return Promise.resolve({
 					error: "max-live-workers",
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots()
 				});
-				const agent = opts.makeWorkerAgent(a.profile);
-				const budget = a.budget === void 0 ? opts.perWorker : mergeBudget(opts.perWorker, a.budget);
-				const res = opts.scope.spawn(agent, a.task, {
+				const parsedProfile = agentProfileSchema.safeParse(a.profile);
+				if (!parsedProfile.success) return Promise.resolve({
+					error: "invalid-profile",
+					issues: parsedProfile.error.issues.map((issue) => ({
+						path: issue.path.join("."),
+						message: issue.message
+					}))
+				});
+				const profile = deepFreezeDetached(parsedProfile.data);
+				const task = deepFreezeDetached(a.task);
+				const label = typeof a.label === "string" ? a.label : "worker";
+				const budget = Object.freeze(a.budget === void 0 ? opts.perWorker : mergeBudget(opts.perWorker, a.budget));
+				const assignmentId = key !== void 0 ? `key:${key}` : `ordinal:${unkeyedAssignmentOrdinal++}`;
+				const context = Object.freeze({
+					assignmentId,
+					parentNodeId: opts.scope.view.root,
+					budget,
+					task,
+					label,
+					...key !== void 0 ? { key } : {}
+				});
+				const res = opts.scope.spawn(() => opts.makeWorkerAgent(profile, context), task, {
 					budget,
-					label: typeof a.label === "string" ? a.label : "worker",
+					label,
+					assignmentId,
 					...key !== void 0 ? { key } : {}
 				});
 				if (res.ok && res.prior?.state === "completed") {
 					const s = res.prior.settled;
 					if (key !== void 0) completedKeys.add(key);
+					const { id, status, resumed: _resumed, ...evidence } = projectSettled(s);
 					return Promise.resolve({
-						workerId: s.handle.id,
+						workerId: id,
 						resumed: "completed",
-						status: "done",
-						score: s.verdict?.score ?? 0,
-						valid: s.verdict?.valid ?? false,
-						outRef: s.outRef,
+						status,
+						...evidence,
 						live: liveWorkerCount(),
 						freeSlots: freeWorkerSlots()
 					});
@@ -5337,6 +6448,10 @@ function createCoordinationTools(opts) {
 				} : {};
 				return Promise.resolve(res.ok ? {
 					workerId: res.handle.id,
+					assignmentId: res.handle.assignmentId ?? assignmentId,
+					...res.handle.identity === void 0 ? {} : { identity: res.handle.identity },
+					...res.handle.materialization === void 0 ? {} : { materialization: res.handle.materialization },
+					...res.handle.executionBindings === void 0 ? {} : { executionBindings: res.handle.executionBindings },
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots(),
 					...priorHistory
@@ -5364,19 +6479,16 @@ function createCoordinationTools(opts) {
 					if (!resumed) return { error: `unknown workerId ${JSON.stringify(id)}` };
 					const output = resumed.outRef ? await opts.blobs.get(resumed.outRef) : void 0;
 					return {
-						status: resumed.status,
-						spent: resumed.spent,
+						...projectNodeEvidence(resumed, true),
 						outRef: resumed.outRef ?? null,
 						output: output ?? null,
-						progress: null,
-						resumed: true
+						progress: null
 					};
 				}
 				const output = node.outRef ? await opts.blobs.get(node.outRef) : void 0;
 				const progress = readProgress(id);
 				return {
-					status: node.status,
-					spent: node.spent,
+					...projectNodeEvidence(node),
 					outRef: node.outRef ?? null,
 					output: output ?? null,
 					progress: progress ?? null
@@ -5406,24 +6518,20 @@ function createCoordinationTools(opts) {
 				const workerId = str(a.workerId, "workerId");
 				const instruction = str(a.instruction, "instruction");
 				const interrupt = a.interrupt === true;
-				const delivered = opts.scope.send(workerId, {
-					steer: instruction,
+				const authorized = authorizeInstruction("steer", workerId, instruction, interrupt);
+				await recordInstruction(authorized);
+				const delivery = await attemptDelivery(authorized, {
+					steer: authorized.instruction,
 					interrupt
 				});
-				await sendDown("steer", {
-					toWorker: workerId,
-					instruction,
-					delivered
-				});
-				if (delivered) return {
-					delivered,
+				if (delivery.delivered) return {
+					delivered: true,
 					progress: readProgress(workerId) ?? null
 				};
-				const progress = readProgress(workerId);
 				return {
-					delivered,
-					reason: !progress ? "unknown-worker" : !progress.live ? "already-settled" : "runtime-has-no-inbox",
-					progress: progress ?? null
+					delivered: false,
+					reason: delivery.outcome,
+					progress: readProgress(workerId) ?? null
 				};
 			}
 		},
@@ -5505,25 +6613,24 @@ function createCoordinationTools(opts) {
 				const questionId = str(a.questionId, "questionId");
 				if (typeof a.answer === "string" && a.answer.length > 0) {
 					const answer = a.answer;
-					const question = decideQuestion(questionId, {
-						kind: "answer",
-						answer,
-						by: typeof a.by === "string" && a.by.length > 0 ? a.by : "user"
-					});
-					const interrupt = question.urgency === "blocks-run" || question.urgency === "blocks-step";
-					const delivered = opts.scope.send(question.from, {
-						answer,
+					const pendingQuestion = questions.find((question) => question.id === questionId);
+					if (pendingQuestion === void 0) throw new Error(`unknown questionId ${JSON.stringify(questionId)}`);
+					const interrupt = pendingQuestion.urgency === "blocks-run" || pendingQuestion.urgency === "blocks-step";
+					const authorized = authorizeInstruction("answer", pendingQuestion.from, answer, interrupt, questionId);
+					await recordInstruction(authorized);
+					const delivery = await attemptDelivery(authorized, {
+						answer: authorized.instruction,
 						questionId,
 						interrupt
 					});
-					await sendDown("answer", {
-						toWorker: question.from,
-						instruction: answer,
-						delivered
-					}, questionId);
 					return {
-						question,
-						delivered
+						question: delivery.delivered ? decideQuestion(questionId, {
+							kind: "answer",
+							answer: authorized.instruction,
+							by: typeof a.by === "string" && a.by.length > 0 ? a.by : "user"
+						}) : pendingQuestion,
+						delivered: delivery.delivered,
+						...delivery.delivered ? {} : { reason: delivery.outcome }
 					};
 				}
 				if (typeof a.deferReason === "string" && a.deferReason.length > 0) return Promise.resolve({ question: decideQuestion(questionId, {
@@ -5689,16 +6796,29 @@ function createCoordinationTools(opts) {
 			handler: async (raw) => {
 				const a = obj(raw);
 				const id = str(a.workerId, "workerId");
-				const node = opts.scope.view.nodes.find((n) => n.id === id);
+				const node = nodeForWorker(id);
 				if (!node) return { error: `unknown workerId ${JSON.stringify(id)}` };
-				if (!node.outRef) return { error: `worker ${JSON.stringify(id)} has not settled — no trace to analyze yet` };
-				const trace = await opts.blobs.get(node.outRef);
-				return { findings: await opts.analysts?.run(str(a.kind, "kind"), trace) };
+				if (isLive(node.status)) return { error: `worker ${JSON.stringify(id)} has not settled — no trace to analyze yet` };
+				const trace = ledger.find((worker) => worker.id === id)?.trace ?? node.trace ?? {
+					status: "unavailable",
+					reason: "legacy-settlement-without-trace-evidence"
+				};
+				let store;
+				try {
+					store = await workerTraceAnalysisStore(trace, opts.blobs);
+				} catch (error) {
+					return {
+						error: error instanceof Error ? error.message : String(error),
+						trace
+					};
+				}
+				return { findings: await opts.analysts?.run(str(a.kind, "kind"), store) };
 			}
 		});
 	}
 	return {
 		tools,
+		ready,
 		history: () => bus.history(),
 		raiseFinding: (finding) => bus.publish({
 			type: "finding",
@@ -5713,6 +6833,31 @@ function createCoordinationTools(opts) {
 		drainResolved
 	};
 }
+function nextUnkeyedAssignmentOrdinal(scope) {
+	let next = 0;
+	const views = [scope.resume?.view, scope.view];
+	for (const view of views) {
+		if (view === void 0) continue;
+		for (const node of view.nodes) {
+			const match = /^ordinal:(\d+)$/.exec(node.assignmentId ?? "");
+			if (match === null) continue;
+			const ordinal = Number(match[1]);
+			if (!Number.isSafeInteger(ordinal)) throw new Error(`coordination: durable assignment id '${node.assignmentId}' exceeds the safe ordinal range`);
+			next = Math.max(next, ordinal + 1);
+		}
+	}
+	if (!Number.isSafeInteger(next)) throw new Error("coordination: durable assignment ordinal space is exhausted");
+	return next;
+}
+function deepFreezeDetached(value) {
+	return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value !== "object" || seen.has(value)) return value;
+	seen.add(value);
+	for (const child of Object.values(value)) deepFreeze(child, seen);
+	return Object.freeze(value);
+}
 //#endregion
 //#region src/runtime/anytime.ts
 /**
@@ -6132,10 +7277,11 @@ const runawayTripwireTurns = 2e3;
 *  overspend usd up to the turn tripwire). */
 function poolStarved(scope, perWorker) {
 	const b = scope.budget;
-	if (b.reservedTokens > 0) return false;
+	if (scope.view.inFlight > 0 || scope.view.waiting > 0) return false;
 	const tokenStarved = b.tokensLeft < perWorker.maxTokens;
-	const usdStarved = b.usdCapped && b.usdLeft <= 0;
-	return tokenStarved || usdStarved;
+	const iterationStarved = b.iterationsLeft <= 0;
+	const usdStarved = b.usdCapped && (b.usdLeft <= 0 || perWorker.maxUsd !== void 0 && b.usdLeft < perWorker.maxUsd);
+	return tokenStarved || iterationStarved || usdStarved;
 }
 /** The absolute wall-clock deadline (when the root set one) has passed. */
 function deadlinePassed(scope, now) {
@@ -6168,17 +7314,29 @@ function driverAgent(opts) {
 	if ((opts.extraTools?.length ?? 0) > 0 && typeof opts.executeExtraTool !== "function") throw new ValidationError("driverAgent: extraTools requires executeExtraTool (how to run a work-tool call)");
 	if ((opts.analyzeOnSettle?.length ?? 0) > 0 && !opts.analysts) throw new ValidationError("driverAgent: analyzeOnSettle requires analysts (the lens registry the kinds resolve against)");
 	const reserved = new Set(coordinationVerbNames);
-	for (const t of opts.extraTools ?? []) if (reserved.has(t.name)) throw new ValidationError(`driverAgent: extra work tool "${t.name}" collides with a coordination verb`);
+	for (const tool of opts.nodeTools ?? []) {
+		if (reserved.has(tool.name)) throw new ValidationError(`driverAgent: node tool "${tool.name}" collides with a coordination verb or another node tool`);
+		reserved.add(tool.name);
+	}
+	for (const t of opts.extraTools ?? []) {
+		if (reserved.has(t.name)) throw new ValidationError(`driverAgent: extra work tool "${t.name}" collides with a coordination verb or node tool`);
+		reserved.add(t.name);
+	}
 	if (opts.maxTurns !== void 0 && opts.maxTurns < 0) throw new ValidationError("driverAgent: maxTurns must be >= 0 (0 lifts the turn cap; bounds become the conserved pool + deadline + abort)");
 	const maxTurns = opts.maxTurns === 0 ? runawayTripwireTurns : opts.maxTurns ?? 16;
 	const now = opts.now ?? Date.now;
+	const inbox = opts.inbox ?? createInbox();
 	return {
 		name: opts.name,
+		deliver(message) {
+			return inbox.deliver(message);
+		},
 		async act(task, scope) {
 			const coord = createCoordinationTools({
 				scope,
 				blobs: opts.blobs,
 				makeWorkerAgent: opts.makeWorkerAgent,
+				...opts.authorizeDownMessage ? { authorizeDownMessage: opts.authorizeDownMessage } : {},
 				perWorker: opts.perWorker,
 				...opts.deliverable ? { deliverable: opts.deliverable } : {},
 				...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
@@ -6187,28 +7345,41 @@ function driverAgent(opts) {
 				...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 				...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
 				...opts.onEvent ? { onEvent: opts.onEvent } : {},
+				...opts.replaySettlements ? { replaySettlements: true } : {},
 				...opts.priorCoordination?.questions.length ? { priorQuestions: opts.priorCoordination.questions } : {}
 			});
+			await coord.ready();
 			for (const w of scope.resume?.waits ?? []) {
 				const rearmed = scope.wait(w.spec, { label: w.label });
 				if (!rearmed.ok) throw new RuntimeRunStateError(`driverAgent: cannot re-arm resumed wait '${w.label}' (${rearmed.reason})`);
 			}
-			const byName = new Map(coord.tools.map((t) => [t.name, t]));
-			const toolSpecs = [...coord.tools.map((t) => ({
-				type: "function",
-				function: {
-					name: t.name,
-					description: t.description,
-					parameters: t.inputSchema
-				}
-			})), ...(opts.extraTools ?? []).map((t) => ({
-				type: "function",
-				function: {
-					name: t.name,
-					description: t.description,
-					parameters: t.parameters
-				}
-			}))];
+			const byName = new Map([...coord.tools, ...opts.nodeTools ?? []].map((t) => [t.name, t]));
+			const toolSpecs = [
+				...coord.tools.map((t) => ({
+					type: "function",
+					function: {
+						name: t.name,
+						description: t.description,
+						parameters: t.inputSchema
+					}
+				})),
+				...(opts.nodeTools ?? []).map((t) => ({
+					type: "function",
+					function: {
+						name: t.name,
+						description: t.description,
+						parameters: t.inputSchema
+					}
+				})),
+				...(opts.extraTools ?? []).map((t) => ({
+					type: "function",
+					function: {
+						name: t.name,
+						description: t.description,
+						parameters: t.parameters
+					}
+				}))
+			];
 			const system = typeof opts.systemPrompt === "function" ? opts.systemPrompt(task) : opts.systemPrompt;
 			const tracker = opts.stopRule ? createProgressTracker({ now }) : void 0;
 			let progressStopReason;
@@ -6288,20 +7459,32 @@ function driverAgent(opts) {
 					...scope.resume ? [{
 						role: "user",
 						content: resumeBrief(scope.resume, opts.priorCoordination)
+					}] : hasPriorCoordination(opts.priorCoordination) ? [{
+						role: "user",
+						content: priorCoordinationBrief(opts.priorCoordination)
 					}] : []
 				],
 				maxTurns,
-				hooks: { stopBefore: () => {
-					if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)) return true;
-					if (!opts.stopRule || !tracker) return false;
-					const decision = progressStop(tracker, opts.stopRule, coord, scope, now, opts.stallAfterMs);
-					if (!decision.stop) return false;
-					if (progressStopReason === void 0) {
-						progressStopReason = decision.reason;
-						opts.onProgressStop?.(decision.reason);
+				hooks: {
+					beforeTurn: (_turn, messages) => {
+						const pending = inbox.drain();
+						if (pending.length > 0) messages.push({
+							role: "user",
+							content: inbox.fold(pending)
+						});
+					},
+					stopBefore: () => {
+						if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)) return true;
+						if (!opts.stopRule || !tracker) return false;
+						const decision = progressStop(tracker, opts.stopRule, coord, scope, now, opts.stallAfterMs);
+						if (!decision.stop) return false;
+						if (progressStopReason === void 0) {
+							progressStopReason = decision.reason;
+							opts.onProgressStop?.(decision.reason);
+						}
+						return true;
 					}
-					return true;
-				} }
+				}
 			});
 			await coord.drainResolved();
 			const submitted = coord.submittedResult();
@@ -6318,8 +7501,9 @@ function driverAgent(opts) {
 /**
 * The factual context a resumed driver starts from — everything the durable stores prove about
 * the prior process(es): committed settlements, per-key states (completed / lost / failed),
-* re-armed waits, carried-over questions and findings, and the spend already paid. Injected as
-* the brain's first user-context on a resumed run so it continues from the unresolved work.
+* re-armed waits, carried-over questions/findings/continuation receipts, and spend already paid.
+* Injected as the brain's first user-context on a resumed run so it continues from unresolved work;
+* old continuation receipts are evidence and are never auto-delivered.
 */
 function resumeBrief(resume, prior) {
 	const lines = [
@@ -6339,13 +7523,36 @@ function resumeBrief(resume, prior) {
 	if (lost.length > 0) lines.push("", "Keys LOST in flight with the prior process — this is the unresolved work; spawn_agent with the same key starts a fresh attempt:", ...lost.map(([k, v]) => `- ${k} (prior attempt ${v.id}, ${v.label})`));
 	if (failed.length > 0) lines.push("", "Keys whose prior attempt FAILED (settled down) — spawn_agent with the same key retries:", ...failed.map(([k, v]) => `- ${k} (prior attempt ${v.id}, ${v.label})`));
 	if (resume.waits.length > 0) lines.push("", "Pending waits RE-ARMED on their original deadlines (they settle through await_event):", ...resume.waits.map((w) => `- ${w.label} (${w.spec.kind})`));
-	const openQuestions = (prior?.questions ?? []).filter((q) => q.status === "open" || q.status === "escalated");
-	if (openQuestions.length > 0) lines.push("", "Questions carried over, still undecided (answer_question decides them; list_questions shows all):", ...openQuestions.map((q) => `- [${q.id}] from=${q.from}, urgency=${q.urgency}: ${q.question}`));
-	if ((prior?.findings.length ?? 0) > 0) lines.push("", "Analyst findings from the prior process:", ...(prior?.findings ?? []).map((f) => `- ${f.analyst} on ${f.fromWorker}: ${safeJson(f.findings)}`));
+	appendPriorCoordination(lines, prior);
 	const spent = resume.priorSpend;
 	lines.push("", "Budget the run ALREADY spent before this process (it counts toward the run total):", `- child work: tokens in=${spent.childWork.tokens.input} out=${spent.childWork.tokens.output}, usd=${spent.childWork.usd}, iterations=${spent.childWork.iterations}`, `- driver inference: tokens in=${spent.driverInference.tokens.input} out=${spent.driverInference.tokens.output}, usd=${spent.driverInference.usd}`);
 	return lines.join("\n");
 }
+function hasPriorCoordination(prior) {
+	return prior !== void 0 && (prior.questions.length > 0 || prior.findings.length > 0 || prior.continuations.length > 0 || prior.deliveryEvidence.length > 0);
+}
+function priorCoordinationBrief(prior) {
+	const lines = [
+		"PRIOR COORDINATION EVIDENCE: this logical supervisor ran in an earlier process.",
+		"Use the evidence below as context. Never auto-deliver an old continuation; issue a new",
+		"authorized instruction only when current live state still warrants it."
+	];
+	appendPriorCoordination(lines, prior);
+	return lines.join("\n");
+}
+function appendPriorCoordination(lines, prior) {
+	const openQuestions = (prior?.questions ?? []).filter((q) => q.status === "open" || q.status === "escalated");
+	if (openQuestions.length > 0) lines.push("", "Questions carried over, still undecided (answer_question decides them; list_questions shows all):", ...openQuestions.map((q) => `- [${q.id}] from=${q.from}, urgency=${q.urgency}: ${q.question}`));
+	if ((prior?.findings.length ?? 0) > 0) lines.push("", "Analyst findings from the prior process:", ...(prior?.findings ?? []).map((f) => `- ${f.analyst} on ${f.fromWorker}: ${safeJson(f.findings)}`));
+	if ((prior?.continuations.length ?? 0) > 0) {
+		const attempts = new Set((prior?.deliveryEvidence ?? []).filter((event) => event.type === "delivery-attempt").map((event) => event.attempt.receiptId));
+		const outcomes = new Map((prior?.deliveryEvidence ?? []).filter((event) => event.type === "steer" || event.type === "answer").map((event) => [event.down.receiptId, event.down.outcome]));
+		lines.push("", "Authorized continuations committed by the prior process (evidence only; never replayed automatically):", ...(prior?.continuations ?? []).map((continuation) => {
+			const delivery = outcomes.get(continuation.receiptId) ?? (attempts.has(continuation.receiptId) ? "unknown-after-crash" : "not-attempted-before-crash");
+			return `- receipt=${continuation.receiptId}, ${continuation.kind} → ${continuation.toWorker}, instruction=${continuation.instructionDigest}, delivery=${delivery}`;
+		}));
+	}
+}
 /** Run a work tool. A throw is data to the driver (it can recover next turn), not a crash — fold
 *  the error back as a string result. null/undefined passes through (the caller treats it as "not
 *  handled" and falls to the coordination dispatch). */
@@ -7243,203 +8450,6 @@ function canonicalize(value) {
 	return out;
 }
 //#endregion
-//#region src/runtime/supervise/authoring.ts
-/**
-*
-* The supervisor's intelligence is AUTHORING the agents it spawns — not pressing buttons.
-*
-* Every agent here is three things: instructions (system prompt), tools, and a model — its
-* `AgentProfile`. The supervisor's job is to WRITE those profiles: read the task, decompose it,
-* and for each sub-task author a tailored worker recipe. `supervisorInstructions` is the how-to the
-* supervisor reads (its system prompt); `authoredWorker` builds a worker AGENT from a profile the
-* supervisor authored — the authored systemPrompt + model shape the worker's call.
-*
-* The skill is the single OPTIMIZABLE surface: edit it → the supervisor designs better agents.
-* That is the self-improvement lever (the prompt/skill lever), not the execution plumbing.
-*
-* @experimental
-*/
-/** Narrow an untyped `spawn_agent` profile argument to an `AuthoredProfile`, or null if the
-*  supervisor failed to author one (empty/placeholder profile — a skill violation worth catching). */
-function asAuthoredProfile(raw) {
-	const p = raw;
-	if (!p || typeof p.systemPrompt !== "string" || p.systemPrompt.trim().length === 0) return null;
-	return {
-		name: typeof p.name === "string" && p.name.length > 0 ? p.name : "worker",
-		systemPrompt: p.systemPrompt,
-		...typeof p.model === "string" ? { model: p.model } : {}
-	};
-}
-/** The supervisor SKILL — the how-to the supervisor reads (its system prompt). THE optimizable
-*  surface: editing this changes how the supervisor designs every agent it spawns. */
-function supervisorInstructions(opts) {
-	return [
-		"You are a SUPERVISOR. You do NOT do the work yourself — your job is to DESIGN and DRIVE specialist worker agents.",
-		"",
-		"For the task you are given:",
-		"1. DECOMPOSE it into the smallest set of sub-tasks a single focused worker can each deliver.",
-		"2. For EACH sub-task, AUTHOR a worker by calling spawn_agent with a COMPLETE `profile`:",
-		"   • name: a short id for the worker.",
-		"   • systemPrompt: rich, specific instructions for THIS sub-task — tell the worker exactly what to produce, how to use its tools fully, and what \"done\" means. Never a one-liner; write the prompt a power-user would write.",
-		"   • model: the model best suited to this sub-task (omit to use the default).",
-		"   NEVER spawn a worker with an empty profile. The quality of the worker IS the quality of the profile you write.",
-		"3. await_event (kinds:['settled']) to collect each worker. Its result says valid:true only if the deployable check passed.",
-		"4. If a worker did NOT deliver, AUTHOR A NEW worker whose systemPrompt names the SPECIFIC failure and how to fix it — never just retry the same prompt.",
-		"5. Stop (reply with no tool call) once the work is delivered. You cannot declare done yourself — only a delivered (valid:true) worker counts.",
-		...opts?.goal ? ["", `The goal: ${opts.goal}`] : []
-	].join("\n");
-}
-/** Build a worker AGENT from a profile the supervisor authored: the authored `systemPrompt` +
-*  `model` shape the worker's one model call; the deliverable gates settlement (valid ⟺ delivered). */
-function authoredWorker(profile, opts) {
-	let artifact;
-	const model = profile.model ?? opts.cfg.model;
-	const gated = gateOnDeliverable({
-		runtime: "router",
-		async execute(_t, signal) {
-			const res = await routerChatWithUsage({
-				...opts.cfg,
-				model
-			}, [{
-				role: "system",
-				content: profile.systemPrompt
-			}, {
-				role: "user",
-				content: opts.taskPrompt
-			}], {
-				temperature: opts.temperature ?? .4,
-				...signal ? { signal } : {}
-			});
-			artifact = {
-				outRef: contentAddress(res.content),
-				out: res.content,
-				spent: {
-					iterations: 1,
-					tokens: res.usage ?? {
-						input: 0,
-						output: 0
-					},
-					usd: res.costUsd ?? 0,
-					ms: 0
-				}
-			};
-			return artifact;
-		},
-		teardown: () => Promise.resolve({ destroyed: true }),
-		resultArtifact: () => {
-			if (!artifact) throw new Error("authoredWorker: resultArtifact read before execute");
-			return artifact;
-		}
-	}, opts.deliverable);
-	const spec = {
-		profile: { name: profile.name },
-		harness: null,
-		executor: gated
-	};
-	return {
-		name: profile.name,
-		act: async () => "",
-		executorSpec: spec
-	};
-}
-/** Default thresholds for `ProfileRichnessThresholds` — 600 chars / 6 lines minimum system prompt. */
-const defaultProfileRichnessThresholds = {
-	minSystemPromptChars: 600,
-	minSystemPromptLines: 6
-};
-/** Read the system prompt from any authored shape: canonical `prompt.systemPrompt`, the sandbox
-*  `prompt.system` convention, or a bare-string `prompt`. */
-function resolveSystemPrompt(profile) {
-	const pr = profile.prompt;
-	if (typeof pr === "string") return pr;
-	if (pr && typeof pr === "object") {
-		const o = pr;
-		if (typeof o.systemPrompt === "string") return o.systemPrompt;
-		if (typeof o.system === "string") return o.system;
-	}
-	return "";
-}
-/** OBSERVE one authored `AgentProfile` and score its richness (no judge verdict is read). The task
-*  context (`needsMcp`) lets a domain say "this work needs a data/tool MCP" so a missing MCP counts. */
-function assessAuthoredProfile(profile, opts) {
-	const th = {
-		...defaultProfileRichnessThresholds,
-		...opts?.thresholds ?? {}
-	};
-	const systemPrompt = resolveSystemPrompt(profile);
-	const trimmed = systemPrompt.trim();
-	const systemPromptChars = trimmed.length;
-	const systemPromptLines = trimmed ? trimmed.split("\n").filter((l) => l.trim().length > 0).length : 0;
-	const sentenceCount = trimmed ? (trimmed.match(/[.!?](\s|$)/g) ?? []).length || (trimmed ? 1 : 0) : 0;
-	const hasDescription = typeof profile.description === "string" && profile.description.trim().length > 0;
-	const tools = profile.tools;
-	const hasTools = !!tools && Object.keys(tools).length > 0;
-	const skills = profile.resources?.skills;
-	const hasSkills = Array.isArray(skills) && skills.length > 0;
-	const mcp = profile.mcp;
-	const hasMcp = !!mcp && Object.keys(mcp).length > 0;
-	const subagents = profile.subagents;
-	const hasSubagents = !!subagents && Object.keys(subagents).length > 0;
-	const reasons = [];
-	const promptThin = systemPromptChars < th.minSystemPromptChars || systemPromptLines < th.minSystemPromptLines;
-	if (promptThin) reasons.push(`system prompt is thin (${systemPromptChars} chars, ${systemPromptLines} lines; need ≥${th.minSystemPromptChars} chars and ≥${th.minSystemPromptLines} lines)`);
-	if (!hasTools) reasons.push("no tools granted (a worker can only act through the tools you grant it)");
-	if (!hasSkills) reasons.push("no skills attached (no reusable how-to notes injected)");
-	if (opts?.needsMcp && !hasMcp) reasons.push("no MCP server, but the task needs data/tool access");
-	const signals = [
-		!promptThin,
-		hasTools,
-		hasSkills,
-		hasDescription,
-		opts?.needsMcp ? hasMcp : true
-	];
-	const richness = signals.filter(Boolean).length / signals.length;
-	const thin = promptThin || !hasTools && !hasSkills && !hasMcp;
-	return {
-		name: profile.name ?? "worker",
-		systemPrompt,
-		systemPromptChars,
-		systemPromptLines,
-		sentenceCount,
-		hasDescription,
-		hasTools,
-		hasSkills,
-		hasMcp,
-		hasSubagents,
-		richness,
-		thin,
-		reasons
-	};
-}
-/** Turn a {@link ProfileRichness} verdict into a bus-routable `AnalystFinding` (area `profile-quality`).
-*  Severity scales with thinness; the recommended action names the MISSING lever so the supervisor can
-*  re-author. `subject` = the worker name so per-worker findings diff cleanly across re-authors. */
-function profileRichnessFinding(richness, opts) {
-	const analyst_id = opts?.analystId ?? "profile-richness";
-	const subject = richness.name;
-	const claim = richness.thin ? `Worker "${richness.name}" was authored as a THIN profile: ${richness.reasons.join("; ")}.` : `Worker "${richness.name}" was authored as a rich profile (richness ${(richness.richness * 100).toFixed(0)}%).`;
-	return makeFinding({
-		analyst_id,
-		severity: richness.thin ? richness.richness < .25 ? "high" : "medium" : "info",
-		area: "profile-quality",
-		claim,
-		subject,
-		confidence: .9,
-		evidence_refs: [{
-			kind: "metric",
-			uri: `profile:${subject}`,
-			excerpt: `chars=${richness.systemPromptChars} lines=${richness.systemPromptLines} tools=${richness.hasTools} skills=${richness.hasSkills} mcp=${richness.hasMcp} richness=${richness.richness.toFixed(2)}`
-		}],
-		...richness.thin ? { recommended_action: `Re-author "${richness.name}" with: ${richness.reasons.join("; ")}.` } : {},
-		id_basis: computeFindingId({
-			analyst_id,
-			area: "profile-quality",
-			subject,
-			claim: `richness:${richness.thin ? "thin" : "rich"}`
-		})
-	});
-}
-//#endregion
 //#region src/runtime/supervise/delegate.ts
 /**
 *
@@ -7468,15 +8478,15 @@ const defaultDelegateBudget = {
 	maxIterations: 50,
 	maxTokens: 2e5
 };
-/** Build the DEFAULT authoring supervisor profile: a router-brained supervisor (`harness: null`)
+/** Build the DEFAULT authoring supervisor profile: a router-brained supervisor (`harness: cli-base`)
 *  whose standing instruction IS the authoring-agent-profiles skill, so it decomposes the intent and
 *  AUTHORS a worker profile per sub-task. No worker profile is baked in here. */
 function authoringSupervisorProfile(model, override) {
 	return {
 		name: override?.name ?? "delegate-supervisor",
-		harness: null,
-		...model ? { model } : {},
-		systemPrompt: override?.systemPrompt ?? supervisorInstructions()
+		harness: "cli-base",
+		...model ? { model: { default: model } } : {},
+		prompt: { systemPrompt: override?.systemPrompt ?? supervisorInstructions() }
 	};
 }
 /**
@@ -7561,11 +8571,19 @@ function validateDelegateArgs(raw) {
 *  conserved `spentTotal`, so the agent always learns the cost — even on a no-winner, never a faked
 *  output and never a fabricated zero spend. */
 function toDelegateResult(result) {
-	if (result.kind === "no-winner") return {
-		status: "no-winner",
-		reason: result.reason,
-		spentTotal: result.spentTotal
-	};
+	if (result.kind === "no-winner") {
+		const rejection = result.error;
+		const error = typeof rejection?.name === "string" && typeof rejection.message === "string" ? {
+			name: rejection.name,
+			message: rejection.message
+		} : void 0;
+		return {
+			status: "no-winner",
+			reason: result.reason,
+			...error ? { error } : {},
+			spentTotal: result.spentTotal
+		};
+	}
 	return {
 		status: "winner",
 		out: result.out,
@@ -8325,6 +9343,7 @@ async function serveCoordinationMcp(opts) {
 		scope: opts.scope,
 		blobs: opts.blobs,
 		makeWorkerAgent: opts.makeWorkerAgent,
+		...opts.authorizeDownMessage ? { authorizeDownMessage: opts.authorizeDownMessage } : {},
 		perWorker: opts.perWorker,
 		...opts.deliverable ? { deliverable: opts.deliverable } : {},
 		...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
@@ -8334,11 +9353,13 @@ async function serveCoordinationMcp(opts) {
 		...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 		...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
 		...opts.onEvent ? { onEvent: opts.onEvent } : {},
+		...opts.replaySettlements ? { replaySettlements: true } : {},
 		...opts.questionPolicy ? { questionPolicy: opts.questionPolicy } : {},
 		...opts.priorQuestions?.length ? { priorQuestions: opts.priorQuestions } : {}
 	});
+	await coord.ready();
 	const mcp = createMcpServer({
-		extraTools: coord.tools,
+		extraTools: [...coord.tools, ...opts.nodeTools ?? []],
 		serverName: "coordination"
 	});
 	const server = createServer((req, res) => {
@@ -8510,45 +9531,81 @@ function assertCoordinationBinding(binding) {
 }
 /** Build a supervisor `Agent` from its profile: the brain resolves from `profile.harness` (backend-as-data), the same resolution rule as every worker. */
 function supervisorAgent(profile, deps) {
-	const name = profile.name ?? "supervisor";
-	const harness = profile.harness ?? null;
-	const profilePrompt = resolveSupervisorSystemPrompt(profile);
+	const stableProfile = detachedSnapshot(profile, "supervisorAgent profile");
+	const resolveTools = deps.resolveSupervisorTools;
+	const observeNodeEvent = deps.observeNodeEvent;
+	const nodeContextSeed = deps.nodeContext === void 0 ? void 0 : detachedSnapshot(deps.nodeContext, "supervisorAgent node context");
+	if ((resolveTools || observeNodeEvent) && !nodeContextSeed) throw new ValidationError("supervisorAgent: nodeContext is required with resolveSupervisorTools or observeNodeEvent");
+	const name = stableProfile.name ?? "supervisor";
+	const harness = stableProfile.harness === void 0 || stableProfile.harness === null || stableProfile.harness === "cli-base" ? null : stableProfile.harness;
+	const profilePrompt = resolveSupervisorSystemPrompt(stableProfile);
 	const coordination = deps.coordination ? { ...deps.coordination } : void 0;
 	assertCoordinationBinding(coordination);
 	if (harness === null && coordination !== void 0) throw new ConfigError("supervisorAgent: coordination binding is only meaningful for a harness-brained supervisor (profile.harness set). A router-brained supervisor calls the coordination verbs in process and serves no MCP, so this binding would be silently ignored.");
-	if (harness !== null && deps.compaction) throw new ValidationError("supervisorAgent: compaction is only supported for router-brained supervisors (profile.harness null)");
-	if (harness === null) return driverAgent({
-		name,
-		brain: deps.brain ?? routerBrainFromProfile(profile, deps),
-		blobs: deps.blobs,
-		makeWorkerAgent: deps.makeWorkerAgent,
-		perWorker: deps.perWorker,
-		systemPrompt: resolveSupervisorSystemPrompt(profile, defaultSupervisorPrompt) ?? defaultSupervisorPrompt,
-		...deps.deliverable ? { deliverable: deps.deliverable } : {},
-		...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
-		...deps.extraTools ? { extraTools: deps.extraTools } : {},
-		...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
-		...deps.analysts ? { analysts: deps.analysts } : {},
-		...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
-		...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
-		...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
-		...deps.stopRule ? { stopRule: deps.stopRule } : {},
-		...deps.onProgressStop ? { onProgressStop: deps.onProgressStop } : {},
-		...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {},
-		...deps.compaction ? { compaction: deps.compaction } : {},
-		...deps.onEvent ? { onEvent: deps.onEvent } : {},
-		...deps.priorCoordination ? { priorCoordination: deps.priorCoordination } : {},
-		...deps.finalizer ? { finalizer: deps.finalizer } : {}
-	});
+	if (harness !== null && deps.compaction) throw new ValidationError("supervisorAgent: compaction is only supported for router-brained supervisors (profile.harness omitted or cli-base)");
+	if (harness === null) {
+		const brain = deps.brain ?? routerBrainFromProfile(stableProfile, deps);
+		const inbox = createInbox();
+		const build = (priorCoordination, nodeTools, onEvent) => driverAgent({
+			name,
+			brain,
+			blobs: deps.blobs,
+			makeWorkerAgent: deps.makeWorkerAgent,
+			...deps.authorizeDownMessage ? { authorizeDownMessage: deps.authorizeDownMessage } : {},
+			perWorker: deps.perWorker,
+			systemPrompt: resolveSupervisorSystemPrompt(stableProfile, defaultSupervisorPrompt) ?? defaultSupervisorPrompt,
+			...deps.deliverable ? { deliverable: deps.deliverable } : {},
+			...nodeTools?.length ? { nodeTools } : {},
+			...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
+			...deps.extraTools ? { extraTools: deps.extraTools } : {},
+			...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
+			...deps.analysts ? { analysts: deps.analysts } : {},
+			...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
+			...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
+			...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
+			...deps.stopRule ? { stopRule: deps.stopRule } : {},
+			...deps.onProgressStop ? { onProgressStop: deps.onProgressStop } : {},
+			...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {},
+			...deps.compaction ? { compaction: deps.compaction } : {},
+			...onEvent ? { onEvent } : {},
+			...deps.replaySettlements ? { replaySettlements: true } : {},
+			...priorCoordination ? { priorCoordination } : {},
+			...deps.finalizer ? { finalizer: deps.finalizer } : {},
+			inbox
+		});
+		if (!deps.loadPriorCoordination && !resolveTools && !observeNodeEvent) return build(deps.priorCoordination, void 0, deps.onEvent);
+		return {
+			name,
+			deliver(message) {
+				return inbox.deliver(message);
+			},
+			async act(task, scope) {
+				const context = nodeContextSeed ? supervisorNodeContext(nodeContextSeed, stableProfile, task, scope) : void 0;
+				const priorCoordination = await deps.loadPriorCoordination?.();
+				const nodeTools = resolveTools && context ? await bindSupervisorTools(resolveTools, context, scope.signal) : void 0;
+				const onEvent = bindSupervisorNodeObserver(context, observeNodeEvent, deps.onEvent);
+				return build(priorCoordination, nodeTools, onEvent).act(task, scope);
+			}
+		};
+	}
 	const driveHarness = deps.driveHarness;
 	if (!driveHarness) throw new ValidationError(`supervisorAgent: profile.harness="${harness}" needs deps.driveHarness (how to run the harness with the coordination MCP mounted)`);
-	return {
+	const deliver = driveHarness.deliver?.bind(driveHarness);
+	const externalAgent = {
 		name,
+		...deliver ? { deliver(message) {
+			return deliver(message);
+		} } : {},
 		async act(task, scope) {
+			const context = nodeContextSeed ? supervisorNodeContext(nodeContextSeed, stableProfile, task, scope) : void 0;
+			const priorCoordination = deps.loadPriorCoordination ? await deps.loadPriorCoordination() : deps.priorCoordination;
+			const nodeTools = resolveTools && context ? await bindSupervisorTools(resolveTools, context, scope.signal) : void 0;
+			const onEvent = bindSupervisorNodeObserver(context, observeNodeEvent, deps.onEvent);
 			const mcp = await serveCoordinationMcp({
 				scope,
 				blobs: deps.blobs,
 				makeWorkerAgent: deps.makeWorkerAgent,
+				...deps.authorizeDownMessage ? { authorizeDownMessage: deps.authorizeDownMessage } : {},
 				perWorker: deps.perWorker,
 				...coordination?.host !== void 0 ? { host: coordination.host } : {},
 				...coordination?.port !== void 0 ? { port: coordination.port } : {},
@@ -8559,17 +9616,24 @@ function supervisorAgent(profile, deps) {
 				...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
 				...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
 				...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
-				...deps.onEvent ? { onEvent: deps.onEvent } : {},
-				...deps.priorCoordination?.questions.length ? { priorQuestions: deps.priorCoordination.questions } : {}
+				...onEvent ? { onEvent } : {},
+				...deps.replaySettlements ? { replaySettlements: true } : {},
+				...priorCoordination?.questions.length ? { priorQuestions: priorCoordination.questions } : {},
+				...nodeTools?.length ? { nodeTools } : {}
 			});
 			try {
 				try {
 					await driveHarness({
-						profile,
+						profile: stableProfile,
 						...profilePrompt !== void 0 ? { systemPrompt: profilePrompt } : {},
 						task,
 						scope,
-						coordinationMcpUrl: mcp.url
+						coordinationMcpUrl: mcp.url,
+						coordinationTools: (nodeTools ?? []).map(({ name, description, inputSchema }) => ({
+							name,
+							description,
+							inputSchema
+						}))
 					});
 				} catch (error) {
 					if (!mcp.submittedResult()) throw error;
@@ -8588,9 +9652,57 @@ function supervisorAgent(profile, deps) {
 			}
 		}
 	};
+	const runtime = runtimeOwnedScopeOwnerRuntime(driveHarness);
+	return runtime === void 0 ? externalAgent : attestRuntimeOwnedScopeOwner(externalAgent, runtime);
+}
+function supervisorNodeContext(seed, profile, task, scope) {
+	return detachedSnapshot({
+		...seed,
+		nodeId: scope.view.root,
+		profile,
+		task
+	}, "supervisorAgent trusted node context");
+}
+async function bindSupervisorTools(resolveTools, context, signal) {
+	const resolved = await resolveTools(context);
+	if (!Array.isArray(resolved)) throw new ValidationError("supervisorAgent: resolveSupervisorTools must return an array");
+	const invocationContext = Object.freeze({
+		...context,
+		signal
+	});
+	const names = new Set(coordinationVerbNames);
+	return Object.freeze(resolved.map((rawTool, index) => {
+		if (typeof rawTool !== "object" || rawTool === null || Array.isArray(rawTool)) throw new ValidationError(`supervisorAgent: resolved tool at index ${index} must be a descriptor`);
+		const { name, description, inputSchema, handler } = rawTool;
+		if (typeof name !== "string" || name.length === 0) throw new ValidationError(`supervisorAgent: resolved tool at index ${index} needs a non-empty name`);
+		if (names.has(name)) throw new ValidationError(`supervisorAgent: resolved tool "${name}" collides with a coordination verb or another resolved tool`);
+		names.add(name);
+		if (typeof description !== "string" || description.length === 0) throw new ValidationError(`supervisorAgent: resolved tool "${name}" needs a description`);
+		if (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema)) throw new ValidationError(`supervisorAgent: resolved tool "${name}" needs an inputSchema`);
+		if (typeof handler !== "function") throw new ValidationError(`supervisorAgent: resolved tool "${name}" needs a handler`);
+		const descriptor = detachedSnapshot({
+			name,
+			description,
+			inputSchema
+		}, `supervisorAgent resolved tool ${JSON.stringify(name)}`);
+		return Object.freeze({
+			...descriptor,
+			handler: (raw) => handler(detachedSnapshot(raw, `supervisorAgent tool ${JSON.stringify(name)} input`), invocationContext)
+		});
+	}));
+}
+function bindSupervisorNodeObserver(context, observeNodeEvent, onEvent) {
+	if (!observeNodeEvent && !onEvent) return void 0;
+	return async (event, record) => {
+		if (observeNodeEvent) {
+			if (!context) throw new ValidationError("supervisorAgent: observeNodeEvent has no trusted node context");
+			await observeNodeEvent(context, event, record);
+		}
+		await onEvent?.(event, record);
+	};
 }
 function routerBrainFromProfile(profile, deps) {
-	if (!deps.router) throw new ValidationError("supervisorAgent: a router-brained supervisor (harness null) needs deps.router (or deps.brain)");
+	if (!deps.router) throw new ValidationError("supervisorAgent: a router-brained supervisor (harness omitted or cli-base) needs deps.router (or deps.brain)");
 	const modelId = resolveSupervisorModelId(profile);
 	return routerBrain({
 		...deps.router,
@@ -8600,6 +9712,15 @@ function routerBrainFromProfile(profile, deps) {
 //#endregion
 //#region src/runtime/supervise/supervise.ts
 /**
+* `supervise` — the one-call "just invoke the supervisor". Builds + runs a supervisor from its
+* profile with sensible defaults, so the common case is `supervise(profile, task, { backend, budget })`
+* instead of hand-wiring `blobs` / `perWorker` / `journal` / `executors` / `maxDepth`. The raw seams
+* (`supervisorAgent` + `createSupervisor().run`) stay available for power use.
+*
+* `workerFromBackend` derives the worker seam (`makeWorkerAgent`) from a backend config + an optional
+* completion oracle — so "where the workers run" is one data choice, not a hand-rolled factory.
+*/
+/**
 * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
 * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
 * deliver"). The ONE place a backend becomes a spawnable worker.
@@ -8613,28 +9734,291 @@ function routerBrainFromProfile(profile, deps) {
 * ahead of the worker seam.
 */
 function workerFromBackend(backend, deliverable, seams) {
-	return (rawProfile) => {
-		const p = rawProfile ?? {};
-		const name = typeof p.name === "string" && p.name.length > 0 ? p.name : "worker";
-		const spec = {
-			profile: rawProfile,
-			harness: null
-		};
-		const ctx = {
-			signal: new AbortController().signal,
-			seams: seams?.() ?? {}
+	const capturedBackend = captureReusableExecutorConfig(backend, "workerFromBackend");
+	const unscopedNamespace = randomUUID();
+	let unscopedOrdinal = 0;
+	return (rawProfile, spawnContext) => {
+		const parsed = agentProfileSchema.safeParse(canonicalizeAuthoredProfile(rawProfile));
+		if (!parsed.success) throw new ValidationError(`workerFromBackend: invalid AgentProfile: ${parsed.error.message}`);
+		const profile = parsed.data;
+		assertBackendProfileMaterialization(profile, capturedBackend, "workerFromBackend");
+		const name = profile.name ?? "worker";
+		const assignmentId = spawnContext?.assignmentId ?? `unscoped:${unscopedNamespace}:${unscopedOrdinal++}`;
+		const baseFactory = createExecutor(bindReusableExecutorExecutionId(capturedBackend, externalExecutionId("supervised-worker", { assignmentId })));
+		const executorFactory = (spec, ctx) => {
+			const extraSeams = seams?.();
+			const built = baseFactory(spec, extraSeams === void 0 ? ctx : {
+				...ctx,
+				seams: {
+					...extraSeams,
+					...ctx.seams
+				}
+			});
+			return deliverable ? gateOnDeliverable(built, deliverable) : built;
 		};
-		const built = createExecutor(backend)(spec, ctx);
-		const executor = deliverable ? gateOnDeliverable(built, deliverable) : built;
 		return {
 			name,
 			act: async () => "",
 			executorSpec: {
-				...spec,
-				executor
+				profile,
+				harness: null,
+				executorFactory,
+				...spawnContext?.execution ? { execution: spawnContext.execution } : {}
+			}
+		};
+	};
+}
+function externalExecutionId(kind, identity) {
+	return `${kind}-${canonicalCandidateDigest({
+		kind,
+		identity
+	}).slice(7)}`;
+}
+function backendProfileMaterialization(backend) {
+	switch (backend.backend) {
+		case "bridge":
+		case "sandbox":
+		case "provider": return fullProfileMaterialization;
+		case "cli-worktree": return backend.bridge ? fullProfileMaterialization : worktreeCliProfileMaterialization;
+		case "router":
+		case "router-tools":
+		case "pi": return promptModelProfileMaterialization;
+		case "cli": return controlProfileMaterialization;
+	}
+}
+function assertProfileContract(profile, contract, context) {
+	assertProfileMaterialization({
+		contract,
+		changedAxes: profileMaterializationAxes(profile),
+		context
+	});
+}
+function assertBackendProfileMaterialization(profile, backend, context) {
+	assertProfileContract(profile, backendProfileMaterialization(backend), context);
+}
+/**
+* The ROOT router-brained supervisor's materialization claim. The router arm consumes the
+* identity fields, the resolved system prompt (`systemPrompt` + `prompt.instructions` +
+* `resources.instructions`), and the resolved model id (`model.default`); the remaining model
+* HINTS (`small`, `provider`, `reasoningEffort`, `metadata`) are accepted as documented-unhonored
+* router-arm material (`supervisorAgent`'s contract table states each one), so a canonical
+* profile carrying ordinary hints is not refused. Every behavioral axis — tools, permissions,
+* MCP, hooks, modes, subagents, file resources — still fails loud before any compute.
+*/
+const routerSupervisorProfileMaterialization = defineProfileMaterializationContract({
+	name: "router-supervisor-execution",
+	axes: [
+		"name",
+		"description",
+		"version",
+		"tags",
+		"systemPrompt",
+		"instructions",
+		"resourceInstructions",
+		"modelDefault",
+		"modelSmall",
+		"modelProvider",
+		"modelReasoningEffort",
+		"modelMetadata",
+		"harness",
+		"metadata"
+	]
+});
+const coordinationMcpAlias = "agent-runtime-coordination";
+const defaultAllowedMcpHosts = [];
+Object.freeze(defaultAllowedMcpHosts);
+/** Manager-authored profiles are untrusted until product policy says otherwise. Remote MCP and
+* ambient connection grants therefore fail closed by default, in addition to local MCP and hooks. */
+const DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY = Object.freeze({
+	allowLocalMcp: false,
+	allowHooks: false,
+	allowedMcpHosts: defaultAllowedMcpHosts,
+	allowConnections: false
+});
+function isExternalSupervisor(profile) {
+	return profile.harness !== void 0 && profile.harness !== "cli-base";
+}
+function automaticDriverBackendSupported(backend) {
+	return backend.backend === "bridge";
+}
+function backendProfileOverlays(backend) {
+	if (!backend) return [];
+	if (backend.backend === "bridge" && backend.agentProfile) return [backend.agentProfile];
+	if (backend.backend === "cli-worktree" && backend.bridge?.agentProfile) return [backend.bridge.agentProfile];
+	return [];
+}
+/** Run a harness-brained manager through the same executor factory as its children. The manager's
+* full profile is preserved, the live coordination server is added under one reserved alias, and
+* every streamed turn is charged to the manager's scope before it may continue. */
+function driveHarnessFromBackend(backend, executionId, now = Date.now) {
+	const boundBackend = bindReusableExecutorExecutionId(captureReusableExecutorConfig(backend, "driveHarnessFromBackend"), executionId);
+	const baseFactory = createExecutor(boundBackend);
+	let activeExecutor;
+	const drive = async ({ profile, task, scope, coordinationMcpUrl, coordinationTools }) => {
+		const initialBudget = scope.budget;
+		if (!(scope.view.inFlight > 0 || scope.view.waiting > 0) && (initialBudget.tokensLeft <= 0 || initialBudget.iterationsLeft <= 0 || initialBudget.usdCapped && initialBudget.usdLeft <= 0 || initialBudget.deadlineMs > 0 && now() >= initialBudget.deadlineMs)) throw new ValidationError("driveHarnessFromBackend: supervisor budget exhausted");
+		const canonicalDriverProfile = agentProfileSchema.parse(profile);
+		if (canonicalDriverProfile.mcp?.[coordinationMcpAlias] !== void 0) throw new ValidationError(`driveHarnessFromBackend: profile MCP alias ${JSON.stringify(coordinationMcpAlias)} is reserved`);
+		const effectiveProfile = agentProfileSchema.parse({
+			...canonicalDriverProfile,
+			mcp: {
+				...canonicalDriverProfile.mcp,
+				[coordinationMcpAlias]: {
+					transport: "http",
+					url: coordinationMcpUrl
+				}
 			}
+		});
+		const stableCoordinationTools = detachedSnapshot(coordinationTools, "driveHarnessFromBackend coordination tools");
+		const spec = {
+			profile: effectiveProfile,
+			harness: boundBackend.backend === "sandbox" ? effectiveProfile.harness ?? boundBackend.harness ?? null : null
+		};
+		const executor = baseFactory(spec, {
+			signal: scope.signal,
+			node: scopeOwnerExecutorNodeContext(scope),
+			seams: {}
+		});
+		activeExecutor = executor;
+		let completed = false;
+		let started = false;
+		let terminalAccountingCaptured = false;
+		let pendingUsage = [];
+		let teardownStarted = false;
+		const deadlineAtMs = scope.budget.deadlineMs || void 0;
+		const teardownOnce = async (grace) => {
+			if (teardownStarted) return;
+			teardownStarted = true;
+			await teardownExecutor(executor, grace, deadlineAtMs, now);
 		};
+		const meterPending = async () => {
+			if (pendingUsage.length === 0) return;
+			const batch = pendingUsage;
+			pendingUsage = [];
+			await scope.meter(spendFromUsageEvents(batch), {
+				role: "driver",
+				runtime: executor.runtime
+			});
+			const budget = scope.budget;
+			if (budget.tokensLeft <= 0 || budget.usdCapped && budget.usdLeft <= 0 || budget.deadlineMs > 0 && now() >= budget.deadlineMs) throw new ValidationError("driveHarnessFromBackend: supervisor budget exhausted");
+		};
+		let failed = false;
+		let failure;
+		try {
+			const declaration = runtimeOwnedExecutorMaterialization(executor);
+			const executionBinding = runtimeOwnedExecutorExecutionBinding(executor);
+			if (declaration === void 0 || executionBinding === void 0) throw new ValidationError(`driveHarnessFromBackend: built-in runtime ${JSON.stringify(executor.runtime)} has no trusted materialization declaration or execution binding`);
+			await recordScopeOwnerMaterialization(scope, executor.runtime, {
+				...declaration,
+				effectiveProfile: canonicalDriverProfile,
+				platformAttachments: { [coordinationMcpAlias]: {
+					kind: "coordination-mcp",
+					transport: "http",
+					tools: stableCoordinationTools
+				} }
+			}, {
+				...executionBinding,
+				binding: {
+					stableBinding: executionBinding.binding,
+					platformAttachments: { [coordinationMcpAlias]: {
+						transport: "http",
+						url: coordinationMcpUrl
+					} }
+				},
+				descriptor: {
+					...executionBinding.descriptor,
+					coordination: true
+				}
+			});
+			if (executor.budgetExempt) throw new ValidationError(`driveHarnessFromBackend: runtime ${JSON.stringify(executor.runtime)} does not report usage and cannot drive a budgeted supervisor`);
+			started = true;
+			const run = executor.execute(task, scope.signal);
+			if (isAsyncIterable(run)) {
+				for await (const event of run) if (event.kind === "iteration") await meterPending();
+				else pendingUsage.push(event);
+				await meterPending();
+				const artifact = executor.resultArtifact();
+				terminalAccountingCaptured = true;
+				if (artifact.spent.tokensKnown === false || artifact.spent.usdKnown === false) await scope.meter({
+					iterations: 0,
+					tokens: {
+						input: 0,
+						output: 0
+					},
+					...artifact.spent.tokensKnown === false ? { tokensKnown: false } : {},
+					usd: 0,
+					...artifact.spent.usdKnown === false ? { usdKnown: false } : {},
+					ms: 0
+				}, {
+					role: "driver",
+					runtime: executor.runtime,
+					telemetry: "unknown"
+				});
+			} else {
+				const artifact = await run;
+				terminalAccountingCaptured = true;
+				await scope.meter({
+					...artifact.spent,
+					iterations: 0
+				}, {
+					role: "driver",
+					runtime: executor.runtime
+				});
+			}
+			completed = true;
+		} catch (error) {
+			failed = true;
+			failure = error;
+		} finally {
+			try {
+				await meterPending();
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					failure = error;
+				}
+			}
+			if (failed && started && !terminalAccountingCaptured) try {
+				await scope.meter({
+					iterations: 0,
+					tokens: {
+						input: 0,
+						output: 0
+					},
+					tokensKnown: false,
+					usd: 0,
+					usdKnown: false,
+					ms: 0
+				}, {
+					role: "driver",
+					runtime: executor.runtime,
+					telemetry: "unknown-after-failure"
+				});
+			} catch (error) {
+				const budget = scope.budget;
+				if (budget.tokensKnown !== false || budget.usdCapped && budget.usdKnown !== false) failure = error;
+			}
+			try {
+				await teardownOnce(completed ? DEFAULT_SUCCESSFUL_SHUTDOWN_MS : "brutalKill");
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					failure = error;
+				}
+			}
+			if (activeExecutor === executor) activeExecutor = void 0;
+		}
+		if (failed) throw failure;
+	};
+	drive.deliver = (message) => {
+		const deliver = activeExecutor?.deliver;
+		if (!deliver) return false;
+		return deliver.call(activeExecutor, message) !== false;
 	};
+	return attestRuntimeOwnedScopeOwner(drive, "cli");
+}
+function isAsyncIterable(value) {
+	return value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
 /** Resolve one option that may be given as a value OR as a name into `opts.registry`. Both failure
 *  modes name the option, the requested name, and the table it was looked up in — a typo must not
@@ -8648,80 +10032,473 @@ function resolveNamed(option, table, value, registry) {
 	if (entry === void 0) throw new ConfigError(`supervise: opts.${option} = ${JSON.stringify(value)} is not in opts.registry.${table} — the table resolved no entry under that name`);
 	return entry;
 }
-/** A quarter of the token pool per worker → ~4 workers fit before `poolStarved` halts spawning. */
+function captureDeliverable(deliverable, context) {
+	if (typeof deliverable !== "object" || deliverable === null || Array.isArray(deliverable)) throw new ValidationError(`${context}: deliverable must be an object`);
+	if (typeof deliverable.check !== "function") throw new ValidationError(`${context}: deliverable.check must be a function`);
+	return Object.freeze({
+		...detachedSnapshot({ describe: deliverable.describe }, `${context} configuration`),
+		check: deliverable.check
+	});
+}
+/** Capture the public one-call configuration before any asynchronous work starts. Decision data is
+* detached and frozen; executable ports are copied as the exact references selected at intake.
+* Service internals intentionally remain live, while replacing a callback/service on the caller's
+* mutable options object can no longer change an in-flight run. */
+function captureSuperviseOptions(opts) {
+	const { backend, driverBackend, deliverable, resolveDeliverable, router, compaction, watchWorkers, analysts, makeWorkerAgent, blobs, journal, probes, registry, hooks, otel, authorizeSpawn, authorizeMessage, isDriverProfile, brain, driveHarness, resolveDriveHarness, resolveSupervisorTools, onCoordinationEvent, executeExtraTool, stopRule, onProgressStop, finalizer, now, signal, rootHandle, ...decisionData } = opts;
+	const capturedData = detachedSnapshot(decisionData, "supervise options");
+	const capturedBackend = backend === void 0 ? void 0 : snapshotExecutorConfig(backend);
+	const capturedDriverBackend = driverBackend === void 0 ? void 0 : snapshotExecutorConfig(driverBackend);
+	const capturedDeliverable = deliverable === void 0 || typeof deliverable === "string" ? deliverable : captureDeliverable(deliverable, "supervise deliverable");
+	const capturedRouter = router === void 0 ? void 0 : (() => {
+		const { complete, ...routerData } = router;
+		return Object.freeze({
+			...detachedSnapshot(routerData, "supervise router configuration"),
+			...complete === void 0 ? {} : { complete }
+		});
+	})();
+	const capturedCompaction = compaction === void 0 ? void 0 : (() => {
+		const { distill, estimateTokens, onCompact, ...compactionData } = compaction;
+		return Object.freeze({
+			...detachedSnapshot(compactionData, "supervise compaction configuration"),
+			...distill === void 0 ? {} : { distill },
+			...estimateTokens === void 0 ? {} : { estimateTokens },
+			...onCompact === void 0 ? {} : { onCompact }
+		});
+	})();
+	const capturedWatchWorkers = watchWorkers === void 0 ? void 0 : Object.freeze({
+		...detachedSnapshot({ maxFindingsPerWorker: watchWorkers.maxFindingsPerWorker }, "supervise worker-watch configuration"),
+		...watchWorkers.detectors === void 0 ? {} : { detectors: Object.freeze([...watchWorkers.detectors]) }
+	});
+	const capturedAnalysts = analysts === void 0 || typeof analysts === "string" ? analysts : Object.freeze({
+		kinds: detachedSnapshot(analysts.kinds, "supervise analyst kinds"),
+		run: analysts.run
+	});
+	return Object.freeze({
+		...capturedData,
+		...capturedBackend === void 0 ? {} : { backend: capturedBackend },
+		...capturedDriverBackend === void 0 ? {} : { driverBackend: capturedDriverBackend },
+		...capturedDeliverable === void 0 ? {} : { deliverable: capturedDeliverable },
+		...resolveDeliverable === void 0 ? {} : { resolveDeliverable },
+		...capturedRouter === void 0 ? {} : { router: capturedRouter },
+		...capturedCompaction === void 0 ? {} : { compaction: capturedCompaction },
+		...capturedWatchWorkers === void 0 ? {} : { watchWorkers: capturedWatchWorkers },
+		...capturedAnalysts === void 0 ? {} : { analysts: capturedAnalysts },
+		...makeWorkerAgent === void 0 ? {} : { makeWorkerAgent },
+		...blobs === void 0 ? {} : { blobs },
+		...journal === void 0 ? {} : { journal },
+		...probes === void 0 ? {} : { probes },
+		...authorizeSpawn === void 0 ? {} : { authorizeSpawn },
+		...authorizeMessage === void 0 ? {} : { authorizeMessage },
+		...isDriverProfile === void 0 ? {} : { isDriverProfile },
+		...brain === void 0 ? {} : { brain },
+		...driveHarness === void 0 ? {} : { driveHarness },
+		...resolveDriveHarness === void 0 ? {} : { resolveDriveHarness },
+		...resolveSupervisorTools === void 0 ? {} : { resolveSupervisorTools },
+		...onCoordinationEvent === void 0 ? {} : { onCoordinationEvent },
+		...executeExtraTool === void 0 ? {} : { executeExtraTool },
+		...stopRule === void 0 ? {} : { stopRule },
+		...onProgressStop === void 0 ? {} : { onProgressStop },
+		...finalizer === void 0 ? {} : { finalizer },
+		...now === void 0 ? {} : { now },
+		...signal === void 0 ? {} : { signal },
+		...rootHandle === void 0 ? {} : { rootHandle },
+		...registry === void 0 ? {} : { registry },
+		...hooks === void 0 ? {} : { hooks },
+		...otel === void 0 ? {} : { otel }
+	});
+}
+/** A quarter of token and optional dollar capacity per worker; nested managers partition again. */
 function defaultPerWorker(budget) {
 	return {
-		maxIterations: budget.maxIterations,
-		maxTokens: Math.max(1, Math.floor(budget.maxTokens / 4))
+		maxIterations: Math.max(1, Math.floor(budget.maxIterations / 4)),
+		maxTokens: Math.max(1, Math.floor(budget.maxTokens / 4)),
+		...budget.maxUsd !== void 0 ? { maxUsd: budget.maxUsd / 4 } : {}
 	};
 }
+function freezeDetached(value) {
+	return detachedSnapshot(value, "supervise");
+}
+function freezeDetachedProfile(value) {
+	return freezeDetached(agentProfileSchema.parse(value));
+}
+/**
+* Map the two loose `SupervisorProfile` spellings onto their canonical `AgentProfile` form before
+* the strict schema parse, so both documented spellings run the SAME canonical pipeline and share
+* one identity digest:
+*  - a string `model` IS `model.default`;
+*  - a top-level `systemPrompt` IS `prompt.systemPrompt` (two disagreeing values are a fault);
+*  - `harness: null` selects the router brain, which canonically is an ABSENT harness.
+* A canonical profile passes through byte-identical; every other field is left for the schema to
+* accept or refuse.
+*/
+function canonicalSupervisorProfileInput(profile) {
+	if (typeof profile !== "object" || profile === null) return profile;
+	const { harness, model, systemPrompt, prompt, ...rest } = profile;
+	const promptSystem = prompt?.systemPrompt;
+	if (systemPrompt !== void 0 && promptSystem !== void 0 && systemPrompt !== promptSystem) throw new ValidationError("supervise: profile.prompt.systemPrompt and profile.systemPrompt are both set and differ — they are the same standing instruction, so keep exactly one");
+	const canonicalPrompt = systemPrompt !== void 0 ? {
+		...prompt,
+		systemPrompt
+	} : prompt;
+	return {
+		...rest,
+		...harness === null || harness === void 0 ? {} : { harness },
+		...model === void 0 ? {} : { model: typeof model === "string" ? { default: model } : model },
+		...canonicalPrompt === void 0 ? {} : { prompt: canonicalPrompt }
+	};
+}
+function canonicalExecution(profile, task, rawExecution, context) {
+	const execution = rawExecution === void 0 ? void 0 : freezeDetached(rawExecution);
+	if (execution !== void 0) {
+		if (typeof execution !== "object" || execution === null || Array.isArray(execution)) throw new ValidationError(`${context}: execution must be an object`);
+		const unknown = Object.keys(execution).filter((key) => key !== "candidateDigest" && key !== "correlation");
+		if (unknown.length > 0) throw new ValidationError(`${context}: unknown execution fields: ${unknown.join(", ")}`);
+	}
+	const identity = deriveNodeExecutionIdentity({
+		profile,
+		execution
+	}, task);
+	if (!identity?.profileDigest || !identity.taskDigest) throw new ValidationError(`${context}: profile and task must be finite, acyclic canonical JSON for durable identity`);
+	const ref = identity.candidateDigest || identity.correlation ? Object.freeze({
+		...identity.candidateDigest ? { candidateDigest: identity.candidateDigest } : {},
+		...identity.correlation ? { correlation: identity.correlation } : {}
+	}) : void 0;
+	return {
+		identity,
+		...ref ? { ref } : {}
+	};
+}
+function rootCoordinationOwner(identity) {
+	return canonicalCandidateDigest({
+		kind: "supervisor-root",
+		identity
+	});
+}
+function childCoordinationOwner(parentOwnerId, identity, context, depth) {
+	return canonicalCandidateDigest({
+		kind: "supervisor-child",
+		parentOwnerId,
+		identity,
+		assignment: {
+			id: context.assignmentId,
+			label: context.label,
+			key: context.key ?? null,
+			depth
+		}
+	});
+}
+function supervisionRunNamespace(runDir, runId) {
+	return canonicalCandidateDigest(runDir === void 0 ? {
+		kind: "supervise-ephemeral-run",
+		runId,
+		nonce: randomUUID()
+	} : {
+		kind: "supervise-durable-run",
+		runId,
+		runDir: resolve(runDir)
+	});
+}
+function workerAssignmentNamespace(runNamespace, parentOwnerId, assignmentId) {
+	return canonicalCandidateDigest({
+		kind: "supervise-worker-assignment",
+		runNamespace,
+		parentOwnerId,
+		assignmentId
+	});
+}
+/** Hash only durable coordination meaning. Bus sequence/timestamp are delivery metadata and a
+* resumed projection's marker describes the reader, not the original settlement. */
+function coordinationEventId(context, event) {
+	const durableEvent = event.type === "settled" && event.worker.resumed === true ? (() => {
+		const { resumed: _resumed, ...worker } = event.worker;
+		return {
+			type: "settled",
+			worker
+		};
+	})() : event;
+	return canonicalCandidateDigest({
+		kind: "supervise-coordination-event",
+		runNamespace: context.runNamespace,
+		ownerId: context.ownerId,
+		event: detachedSnapshot(durableEvent, "supervise coordination event identity")
+	});
+}
 /** One-call supervisor: build + run a supervisor from its profile with sensible defaults; the raw `supervisorAgent` + `createSupervisor().run` seams stay available for power use. */
 function supervise(profile, task, opts) {
-	const backendModel = opts.backend?.model;
-	assertModelAllowed(opts.router?.model, opts.allowedModels);
-	assertModelAllowed(resolveSupervisorModelId(profile), opts.allowedModels);
-	assertModelAllowed(typeof backendModel === "string" ? backendModel : void 0, opts.allowedModels);
-	const deliverable = resolveNamed("deliverable", "deliverables", opts.deliverable, opts.registry?.deliverables);
-	const finalizer = resolveNamed("finalizer", "finalizers", opts.finalizer, opts.registry?.finalizers);
-	const analysts = resolveNamed("analysts", "analysts", opts.analysts, opts.registry?.analysts);
-	const probes = resolveNamed("probes", "probes", opts.probes, opts.registry?.probes);
-	assertCoordinationBinding(opts.coordination);
-	const ctx = opts.runDir !== void 0 ? createFileRunContext(opts.runDir, { withDriver: true }) : createInMemoryRunContext({ withDriver: true });
-	const blobs = opts.blobs ?? ctx.blobs;
-	const perWorker = opts.perWorker ?? defaultPerWorker(opts.budget);
-	const runId = opts.runId ?? "supervise";
+	const options = captureSuperviseOptions(opts);
+	assertValidBudget(options.budget, "supervise budget");
+	const parsedProfile = agentProfileSchema.safeParse(canonicalSupervisorProfileInput(profile));
+	if (!parsedProfile.success) throw new ValidationError(`supervise: invalid AgentProfile: ${parsedProfile.error.message}`);
+	const canonicalProfile = freezeDetachedProfile(parsedProfile.data);
+	const canonicalTask = freezeDetached(task);
+	if (options.makeWorkerAgent && options.authorizeSpawn) throw new ValidationError("supervise: authorizeSpawn cannot be combined with caller-owned makeWorkerAgent; wrap and authorize the custom factory explicitly or use backend-derived workers");
+	if (options.makeWorkerAgent && options.resolveDeliverable) throw new ValidationError("supervise: resolveDeliverable applies only to backend-derived workers; wrap a caller-owned makeWorkerAgent with its completion checks explicitly");
+	const authorizeDownFor = (parent, depth) => {
+		if (!options.authorizeSpawn && !options.authorizeMessage) return void 0;
+		return (input) => {
+			if (!options.authorizeMessage) throw new ValidationError("supervise: authorizeMessage is required before steer_agent or answer_question when authorizeSpawn is enabled");
+			return freezeDetached(options.authorizeMessage(freezeDetached({
+				...input,
+				parent,
+				depth
+			})));
+		};
+	};
+	const rootExecution = canonicalExecution(canonicalProfile, canonicalTask, options.execution, "supervise root");
+	const backendModel = options.backend?.model;
+	const driverBackendModel = options.driverBackend?.model;
+	if ([...backendProfileOverlays(options.backend), ...backendProfileOverlays(options.driverBackend)].length > 0) throw new ValidationError("supervise: backend agentProfile overlays are not allowed because they run after spawn authorization; merge the overlay into the exact profile before calling supervise");
+	assertModelAllowed(options.router?.model, options.allowedModels);
+	assertProfileModelsAllowed(canonicalProfile, options.allowedModels);
+	assertModelAllowed(typeof backendModel === "string" ? backendModel : void 0, options.allowedModels);
+	assertModelAllowed(typeof driverBackendModel === "string" ? driverBackendModel : void 0, options.allowedModels);
+	const deliverable = resolveNamed("deliverable", "deliverables", options.deliverable, options.registry?.deliverables);
+	const finalizer = resolveNamed("finalizer", "finalizers", options.finalizer, options.registry?.finalizers);
+	const analysts = resolveNamed("analysts", "analysts", options.analysts, options.registry?.analysts);
+	const probes = resolveNamed("probes", "probes", options.probes, options.registry?.probes);
+	assertCoordinationBinding(options.coordination);
+	const ctx = options.runDir !== void 0 ? createFileRunContext(options.runDir, { withDriver: true }) : createInMemoryRunContext({ withDriver: true });
+	const blobs = options.blobs ?? ctx.blobs;
+	const perWorker = options.perWorker ?? defaultPerWorker(options.budget);
+	assertValidBudget(perWorker, "supervise perWorker");
+	const journal = options.journal ?? ctx.journal;
+	const runId = options.runId ?? "supervise";
+	const runNamespace = supervisionRunNamespace(options.runDir, runId);
 	const log = ctx.coordinationLog;
-	const now = opts.now ?? Date.now;
+	const rootOwnerId = rootCoordinationOwner(rootExecution.identity);
+	const observeNodeEvent = options.onCoordinationEvent ? async (context, event, record) => {
+		await options.onCoordinationEvent?.(context, coordinationEventId(context, event), record);
+	} : void 0;
+	const managerBackend = options.driverBackend ?? options.backend;
+	if (options.driveHarness && options.resolveDriveHarness) throw new ValidationError("supervise: provide driveHarness or resolveDriveHarness, not both");
+	const driverMaterialization = Boolean(options.driveHarness || options.resolveDriveHarness) ? options.driveHarnessMaterialization ?? fullProfileMaterialization : managerBackend && automaticDriverBackendSupported(managerBackend) ? backendProfileMaterialization(managerBackend) : void 0;
+	if (isExternalSupervisor(canonicalProfile) && !options.driveHarness && !options.resolveDriveHarness && (!managerBackend || !automaticDriverBackendSupported(managerBackend))) throw new ValidationError(`supervise: external supervisor profile.harness=${JSON.stringify(canonicalProfile.harness)} requires a local bridge driverBackend, an explicit driveHarness, or resolveDriveHarness with reachable coordination transport`);
+	const harnessClaims = /* @__PURE__ */ new WeakMap();
+	const claimDriveHarness = (rawHarness, ownerId) => {
+		if (typeof rawHarness !== "function") throw new ValidationError("supervise: resolveDriveHarness must return a DriveHarness function");
+		const harness = rawHarness;
+		const deliver = harness.deliver;
+		if (deliver !== void 0 && typeof deliver !== "function") throw new ValidationError("supervise: driveHarness.deliver must be a function when provided");
+		const claim = harnessClaims.get(harness);
+		const conflictingOwner = claim ? [...claim.owners].find((claimedOwner) => claimedOwner !== ownerId) : void 0;
+		const steerable = typeof deliver === "function";
+		if (conflictingOwner !== void 0 && (steerable || claim?.steerable === true)) throw new ValidationError(`supervise: steerable driveHarness is already bound to manager owner ${JSON.stringify(conflictingOwner)}; resolveDriveHarness must return a distinct steerable instance for owner ${JSON.stringify(ownerId)}`);
+		if (claim) {
+			claim.owners.add(ownerId);
+			claim.steerable ||= steerable;
+		} else harnessClaims.set(harness, {
+			owners: /* @__PURE__ */ new Set([ownerId]),
+			steerable
+		});
+		return harness;
+	};
+	const driveHarnessForOwner = (context) => {
+		if (options.resolveDriveHarness) return claimDriveHarness(options.resolveDriveHarness(context), context.ownerId);
+		if (options.driveHarness) return claimDriveHarness(options.driveHarness, context.ownerId);
+		return managerBackend && automaticDriverBackendSupported(managerBackend) ? driveHarnessFromBackend(managerBackend, externalExecutionId("supervised-manager", {
+			runNamespace,
+			ownerId: context.ownerId
+		}), options.now ?? Date.now) : void 0;
+	};
+	const rootDriveHarness = isExternalSupervisor(canonicalProfile) ? driveHarnessForOwner(freezeDetached({
+		runId,
+		runNamespace,
+		ownerId: rootOwnerId,
+		depth: 0,
+		identity: rootExecution.identity,
+		profile: canonicalProfile,
+		task: canonicalTask
+	})) : void 0;
+	const rootOwnerRuntime = !isExternalSupervisor(canonicalProfile) || rootDriveHarness === void 0 ? void 0 : runtimeOwnedScopeOwnerRuntime(rootDriveHarness);
+	assertProfileContract(canonicalProfile, isExternalSupervisor(canonicalProfile) ? driverMaterialization : options.brain ? promptControlProfileMaterialization : routerSupervisorProfileMaterialization, "supervise root");
+	const now = options.now ?? Date.now;
 	let spans;
-	let makeWorkerAgent = opts.makeWorkerAgent;
+	let makeWorkerAgent = options.makeWorkerAgent;
 	if (!makeWorkerAgent) {
-		if (!opts.backend) throw new ValidationError("supervise: provide opts.backend (where workers run) or opts.makeWorkerAgent");
-		makeWorkerAgent = workerFromBackend(opts.backend, deliverable, () => spans ? { [workerTraceSeamKey]: spans.workerTrace(runId) } : {});
+		if (!options.backend) throw new ValidationError("supervise: provide opts.backend (where workers run) or opts.makeWorkerAgent");
+		const makeLeaf = workerFromBackend(options.backend, deliverable);
+		const securityPolicy = options.profileSecurity ?? DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY;
+		const makeRecursiveWorkerFor = (parent, parentIdentity, depth, parentOwnerId) => {
+			const makeRecursiveWorker = (authoredProfile, spawnContext) => {
+				if (!spawnContext) throw new ValidationError("supervise: backend-derived workers require spawn context");
+				const input = freezeDetachedProfile(authoredProfile);
+				const authorizationInput = Object.freeze({
+					profile: input,
+					parent,
+					parentIdentity,
+					parentNodeId: spawnContext.parentNodeId,
+					assignmentId: spawnContext.assignmentId,
+					task: spawnContext.task,
+					budget: spawnContext.budget,
+					label: spawnContext.label,
+					...spawnContext.key !== void 0 ? { key: spawnContext.key } : {},
+					depth
+				});
+				const decision = options.authorizeSpawn ? freezeDetached(options.authorizeSpawn(authorizationInput)) : Object.freeze({
+					profile: input,
+					...spawnContext.execution ? { execution: spawnContext.execution } : {}
+				});
+				if (typeof decision !== "object" || decision === null || Array.isArray(decision)) throw new ValidationError("supervise: authorizeSpawn must return an AuthorizedSpawn");
+				const authorized = freezeDetachedProfile(decision.profile);
+				const childExecution = canonicalExecution(authorized, spawnContext.task, decision.execution, `supervise spawn ${JSON.stringify(spawnContext.label)}`);
+				const authorizedContext = Object.freeze({
+					...spawnContext,
+					...childExecution.ref ? { execution: childExecution.ref } : {}
+				});
+				const postAuthorizationContext = freezeDetached({
+					profile: authorized,
+					parent,
+					parentIdentity,
+					execution: childExecution.identity,
+					parentNodeId: spawnContext.parentNodeId,
+					assignmentId: spawnContext.assignmentId,
+					task: spawnContext.task,
+					budget: spawnContext.budget,
+					label: spawnContext.label,
+					...spawnContext.key !== void 0 ? { key: spawnContext.key } : {},
+					depth
+				});
+				const security = validateAgentProfileSecurity(authorized, securityPolicy);
+				if (!security.ok) throw new ValidationError(`supervise: spawned AgentProfile refused: ${security.issues.filter((issue) => issue.level === "error").map((issue) => `${issue.code}${issue.path ? ` at ${issue.path}` : ""}`).join(", ")}`);
+				assertProfileModelsAllowed(authorized, options.allowedModels);
+				let isDriver;
+				if (options.isDriverProfile) {
+					const driverDecision = options.isDriverProfile(postAuthorizationContext);
+					if (typeof driverDecision !== "boolean") throw new ValidationError("supervise: isDriverProfile must return a boolean");
+					isDriver = driverDecision;
+				} else isDriver = authorized.metadata?.role === "driver";
+				if (!isDriver) {
+					const selectedDeliverable = options.resolveDeliverable?.(postAuthorizationContext);
+					const leafDeliverable = selectedDeliverable === void 0 ? deliverable : captureDeliverable(selectedDeliverable, `supervise deliverable for ${JSON.stringify(spawnContext.label)}`);
+					return (leafDeliverable === deliverable ? makeLeaf : workerFromBackend(options.backend, leafDeliverable))(authorized, Object.freeze({
+						...authorizedContext,
+						assignmentId: workerAssignmentNamespace(runNamespace, parentOwnerId, spawnContext.assignmentId)
+					}));
+				}
+				const ownerId = childCoordinationOwner(parentOwnerId, childExecution.identity, spawnContext, depth);
+				const nestedDriveHarness = isExternalSupervisor(authorized) ? driveHarnessForOwner(freezeDetached({
+					runId,
+					runNamespace,
+					ownerId,
+					depth,
+					identity: childExecution.identity,
+					assignmentId: spawnContext.assignmentId,
+					profile: authorized,
+					task: spawnContext.task
+				})) : void 0;
+				if (isExternalSupervisor(authorized) && !nestedDriveHarness) throw new ValidationError(`supervise: authored external supervisor profile.harness=${JSON.stringify(authorized.harness)} requires a local bridge driverBackend, an explicit driveHarness, or resolveDriveHarness with reachable coordination transport`);
+				assertProfileContract(authorized, isExternalSupervisor(authorized) ? driverMaterialization : promptModelProfileMaterialization, `supervise driver ${JSON.stringify(spawnContext.label)}`);
+				const childFactory = makeRecursiveWorkerFor(authorized, childExecution.identity, depth + 1, ownerId);
+				const nestedPerWorker = defaultPerWorker(spawnContext.budget);
+				const authorizeNestedMessage = authorizeDownFor(authorized, depth + 1);
+				return driverChild(authorized, supervisorAgent(authorized, {
+					blobs,
+					makeWorkerAgent: childFactory,
+					...authorizeNestedMessage ? { authorizeDownMessage: authorizeNestedMessage } : {},
+					perWorker: nestedPerWorker,
+					...options.router ? { router: options.router } : {},
+					...nestedDriveHarness ? { driveHarness: nestedDriveHarness } : {},
+					nodeContext: {
+						runId,
+						runNamespace,
+						ownerId,
+						depth,
+						identity: childExecution.identity,
+						assignmentId: spawnContext.assignmentId
+					},
+					...options.resolveSupervisorTools ? { resolveSupervisorTools: options.resolveSupervisorTools } : {},
+					...observeNodeEvent ? {
+						observeNodeEvent,
+						replaySettlements: true
+					} : {},
+					...analysts ? { analysts } : {},
+					...options.analyzeOnSettle ? { analyzeOnSettle: options.analyzeOnSettle } : {},
+					...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
+					...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
+					...options.stopRule ? { stopRule: options.stopRule } : {},
+					...options.onProgressStop ? { onProgressStop: options.onProgressStop } : {},
+					...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+					...options.compaction ? { compaction: options.compaction } : {},
+					...log ? {
+						onEvent: (_event, record) => log.append(runId, record, ownerId),
+						loadPriorCoordination: () => log.load(runId, ownerId)
+					} : {},
+					...finalizer ? { finalizer } : {}
+				}), journal, childExecution.ref);
+			};
+			return makeRecursiveWorker;
+		};
+		makeWorkerAgent = makeRecursiveWorkerFor(canonicalProfile, rootExecution.identity, 1, rootOwnerId);
 	}
 	const workerFactory = makeWorkerAgent;
 	const start = async () => {
-		const priorCoordination = log ? await log.load(runId) : void 0;
-		const agent = supervisorAgent(profile, {
+		const priorCoordination = log ? await log.load(runId, rootOwnerId) : void 0;
+		const authorizeRootMessage = authorizeDownFor(canonicalProfile, 1);
+		const agent = supervisorAgent(canonicalProfile, {
 			blobs,
 			makeWorkerAgent: workerFactory,
+			...authorizeRootMessage ? { authorizeDownMessage: authorizeRootMessage } : {},
 			perWorker,
+			...log ? { onEvent: (_event, record) => log.append(runId, record, rootOwnerId) } : {},
 			...deliverable ? { deliverable } : {},
-			...log ? { onEvent: (ev) => log.append(runId, ev, new Date(now()).toISOString()) } : {},
-			...priorCoordination && (priorCoordination.questions.length > 0 || priorCoordination.findings.length > 0) ? { priorCoordination } : {},
+			...priorCoordination && (priorCoordination.questions.length > 0 || priorCoordination.findings.length > 0 || priorCoordination.continuations.length > 0 || priorCoordination.deliveryEvidence.length > 0) ? { priorCoordination } : {},
 			...finalizer ? { finalizer } : {},
-			...opts.coordination ? { coordination: opts.coordination } : {},
-			...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
-			...opts.router ? { router: opts.router } : {},
-			...opts.brain ? { brain: opts.brain } : {},
-			...opts.driveHarness ? { driveHarness: opts.driveHarness } : {},
-			...opts.extraTools ? { extraTools: opts.extraTools } : {},
-			...opts.executeExtraTool ? { executeExtraTool: opts.executeExtraTool } : {},
+			...options.coordination ? { coordination: options.coordination } : {},
+			...options.maxLiveWorkers !== void 0 ? { maxLiveWorkers: options.maxLiveWorkers } : {},
+			...options.router ? { router: options.router } : {},
+			...options.brain ? { brain: options.brain } : {},
+			...rootDriveHarness ? { driveHarness: rootDriveHarness } : {},
+			nodeContext: {
+				runId,
+				runNamespace,
+				ownerId: rootOwnerId,
+				depth: 0,
+				identity: rootExecution.identity
+			},
+			...options.resolveSupervisorTools ? { resolveSupervisorTools: options.resolveSupervisorTools } : {},
+			...observeNodeEvent ? {
+				observeNodeEvent,
+				replaySettlements: true
+			} : {},
+			...options.extraTools ? { extraTools: options.extraTools } : {},
+			...options.executeExtraTool ? { executeExtraTool: options.executeExtraTool } : {},
 			...analysts ? { analysts } : {},
-			...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
-			...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
-			...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
-			...opts.stopRule ? { stopRule: opts.stopRule } : {},
-			...opts.onProgressStop ? { onProgressStop: opts.onProgressStop } : {},
-			...opts.maxTurns !== void 0 ? { maxTurns: opts.maxTurns } : {},
-			...opts.compaction ? { compaction: opts.compaction } : {}
+			...options.analyzeOnSettle ? { analyzeOnSettle: options.analyzeOnSettle } : {},
+			...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
+			...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
+			...options.stopRule ? { stopRule: options.stopRule } : {},
+			...options.onProgressStop ? { onProgressStop: options.onProgressStop } : {},
+			...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+			...options.compaction ? { compaction: options.compaction } : {}
 		});
-		spans = opts.otel ? createSupervisorSpanRecorder({
+		spans = options.otel ? createSupervisorSpanRecorder({
 			runId,
-			...opts.otel,
+			...options.otel,
 			now
 		}) : void 0;
 		const recorder = spans;
-		const hooks = recorder ? composeRuntimeHooks(opts.hooks, recorder.hooks) : opts.hooks;
-		const run = createSupervisor().run(agent, task, {
-			budget: opts.budget,
+		const hooks = recorder ? composeRuntimeHooks(options.hooks, recorder.hooks) : options.hooks;
+		const supervisor = createSupervisor();
+		if (options.rootHandle) supervisor.attach(options.rootHandle);
+		const run = supervisor.run(agent, canonicalTask, {
+			budget: options.budget,
 			runId,
-			journal: opts.journal ?? ctx.journal,
+			journal,
 			blobs,
 			executors: ctx.executors,
-			maxDepth: opts.maxDepth ?? 8,
+			rootIdentity: rootExecution.identity,
+			...rootOwnerRuntime === void 0 ? {} : { rootMaterialization: {
+				runtime: rootOwnerRuntime,
+				declaration: "deferred",
+				authoredProfile: canonicalProfile
+			} },
+			maxDepth: options.maxDepth ?? 8,
+			...options.maxLiveWorkers !== void 0 ? { maxLiveWorkers: options.maxLiveWorkers } : {},
 			...probes ? { probes } : {},
 			...ctx.resume === true ? { resume: true } : {},
-			...opts.now ? { now: opts.now } : {},
+			...options.now ? { now: options.now } : {},
+			...options.signal ? { signal: options.signal } : {},
 			...hooks ? { hooks } : {},
 			...recorder ? { workerTrace: recorder.workerTrace } : {}
 		});
@@ -8738,6 +10515,6 @@ function supervise(profile, task, opts) {
 	return start();
 }
 //#endregion
-export { InMemoryDelegationStore as $, FileCoordinationLog as $t, DELEGATE_INPUT_SCHEMA as A, createWorktreeCliExecutor as At, profileRichnessFinding as B, PI_MCP_ADAPTER_ENV as Bt, validateDelegateUiAuditArgs as C, defaultToolDetectors as Ct, createDelegateFeedbackHandler as D, cliWorktreeExecutor as Dt, DELEGATE_FEEDBACK_TOOL_NAME as E, createInMemoryRunContext as Et, delegate as F, piSeamKey as Ft, DELEGATION_TRACE_MAX_SPANS as G, createInbox as Gt, DelegationTaskQueue as H, buildPiMcpServers as Ht, asAuthoredProfile as I, createPushTraceSource as It, composeLoopTraceEmitters as J, runAgentRounds as Jt, buildDelegationTraceSpans as K, createSandboxForSpec as Kt, assessAuthoredProfile as L, decodeToolPart as Lt, createDelegateHandler as M, createSteerableSandboxSession as Mt, validateDelegateArgs as N, PI_RUNTIME as Nt, validateDelegateFeedbackArgs as O, createExecutor as Ot, defaultDelegateBudget as P, piExecutor as Pt, FileDelegationStore as Q, acquireSandbox as Qt, authoredWorker as R, sandboxSessionTraceSource as Rt, createDelegateUiAuditHandler as S, rollingDispatch as St, DELEGATE_FEEDBACK_INPUT_SCHEMA as T, createFileRunContext as Tt, hashIdempotencyInput as U, piMcpAdapterAvailable as Ut, supervisorInstructions as V, PI_MCP_CONFIG_FLAG as Vt, DELEGATION_TRACE_MAX_BYTES as W, preparePiMcp as Wt, DelegationPersistenceError as X, createSandboxLineage as Xt, createDelegationTraceCollector as Y, runLoop as Yt, DelegationStateCorruptError as Z, probeSandboxCapabilities as Zt, createDelegationHistoryHandler as _, createCoordinationTools as _t, supervisorAgent as a, allWorkersStalled as at, DELEGATE_UI_AUDIT_INPUT_SCHEMA as b, freeSlots as bt, createMcpServer as c, noProgressFor as ct, DELEGATION_STATUS_TOOL_NAME as d, anytimeReport as dt, createSupervisorSpanRecorder as en, InMemoryFeedbackStore as et, createDelegationStatusHandler as f, areaUnderCurve as ft, DELEGATION_HISTORY_TOOL_NAME as g, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as gt, DELEGATION_HISTORY_INPUT_SCHEMA as h, renderAnytimeTable as ht, resolveSupervisorProfile as i, allOf as it, DELEGATE_TOOL_NAME as j, DEFAULT_SANDBOX_STEERING_MAX_TURNS as jt, DELEGATE_DESCRIPTION as k, createExecutorRegistry as kt, DELEGATION_STATUS_DESCRIPTION as l, plateau as lt, DELEGATION_HISTORY_DESCRIPTION as m, plateauLength as mt, workerFromBackend as n, gateOnDeliverable as nn, driverAgent as nt, serveCoordinationMcp as o, anyOf as ot, validateDelegationStatusArgs as p, bestSoFar as pt, capDelegationTrace as q, defaultSelectWinner as qt, assertCoordinationBinding as r, finalizeBestDelivered as rt, createInProcessTransport as s, createProgressTracker as st, supervise as t, assertModelAllowed as tn, eventToSnapshot as tt, DELEGATION_STATUS_INPUT_SCHEMA as u, sampleFromSettled as ut, validateDelegationHistoryArgs as v, createEventBus as vt, DELEGATE_FEEDBACK_DESCRIPTION as w, watchTrace as wt, DELEGATE_UI_AUDIT_TOOL_NAME as x, queueOf as xt, DELEGATE_UI_AUDIT_DESCRIPTION as y, effectiveConcurrency as yt, defaultProfileRichnessThresholds as z, PI_MCP_ADAPTER as zt };
+export { allOf as $, profileRichnessFinding as $t, DELEGATE_DESCRIPTION as A, PI_MCP_ADAPTER as At, DELEGATION_TRACE_MAX_SPANS as B, runLoop as Bt, createDelegateUiAuditHandler as C, createSteerableSandboxSession as Ct, DELEGATE_FEEDBACK_TOOL_NAME as D, createPushTraceSource as Dt, DELEGATE_FEEDBACK_INPUT_SCHEMA as E, piSeamKey as Et, defaultDelegateBudget as F, preparePiMcp as Ft, DelegationPersistenceError as G, createSupervisorSpanRecorder as Gt, capDelegationTrace as H, probeSandboxCapabilities as Ht, delegate as I, createInbox as It, InMemoryDelegationStore as J, asAuthoredProfile as Jt, DelegationStateCorruptError as K, assertModelAllowed as Kt, DelegationTaskQueue as L, createSandboxForSpec as Lt, DELEGATE_TOOL_NAME as M, PI_MCP_CONFIG_FLAG as Mt, createDelegateHandler as N, buildPiMcpServers as Nt, createDelegateFeedbackHandler as O, decodeToolPart as Ot, validateDelegateArgs as P, piMcpAdapterAvailable as Pt, finalizeBestDelivered as Q, defaultProfileRichnessThresholds as Qt, hashIdempotencyInput as R, defaultSelectWinner as Rt, DELEGATE_UI_AUDIT_TOOL_NAME as S, DEFAULT_SANDBOX_STEERING_MAX_TURNS as St, DELEGATE_FEEDBACK_DESCRIPTION as T, piExecutor as Tt, composeLoopTraceEmitters as U, acquireSandbox as Ut, buildDelegationTraceSpans as V, createSandboxLineage as Vt, createDelegationTraceCollector as W, FileCoordinationLog as Wt, eventToSnapshot as X, authoredWorker as Xt, InMemoryFeedbackStore as Y, assessAuthoredProfile as Yt, driverAgent as Z, canonicalizeAuthoredProfile as Zt, DELEGATION_HISTORY_TOOL_NAME as _, createInMemoryRunContext as _t, resolveSupervisorProfile as a, sampleFromSettled as at, DELEGATE_UI_AUDIT_DESCRIPTION as b, createExecutorRegistry as bt, createInProcessTransport as c, bestSoFar as ct, DELEGATION_STATUS_INPUT_SCHEMA as d, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dt, supervisorInstructions as en, allWorkersStalled as et, DELEGATION_STATUS_TOOL_NAME as f, createCoordinationTools as ft, DELEGATION_HISTORY_INPUT_SCHEMA as g, createFileRunContext as gt, DELEGATION_HISTORY_DESCRIPTION as h, watchTrace as ht, assertCoordinationBinding as i, plateau as it, DELEGATE_INPUT_SCHEMA as j, PI_MCP_ADAPTER_ENV as jt, validateDelegateFeedbackArgs as k, sandboxSessionTraceSource as kt, createMcpServer as l, plateauLength as lt, validateDelegationStatusArgs as m, defaultToolDetectors as mt, supervise as n, createProgressTracker as nt, supervisorAgent as o, anytimeReport as ot, createDelegationStatusHandler as p, createEventBus as pt, FileDelegationStore as q, assertProfileModelsAllowed as qt, workerFromBackend as r, noProgressFor as rt, serveCoordinationMcp as s, areaUnderCurve as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, gateOnDeliverable as tn, anyOf as tt, DELEGATION_STATUS_DESCRIPTION as u, renderAnytimeTable as ut, createDelegationHistoryHandler as v, cliWorktreeExecutor as vt, validateDelegateUiAuditArgs as w, PI_RUNTIME as wt, DELEGATE_UI_AUDIT_INPUT_SCHEMA as x, createWorktreeCliExecutor as xt, validateDelegationHistoryArgs as y, createExecutor as yt, DELEGATION_TRACE_MAX_BYTES as z, runAgentRounds as zt };
 
-//# sourceMappingURL=supervise-BUR9ByF7.js.map
+//# sourceMappingURL=supervise-U7_K5yuV.js.map