@tangle-network/agent-runtime 0.143.0 → 0.153.1

package/dist/{supervise-hCgG6ROJ.js → supervise-BezbzKiJ.js}

@@ -1,1127 +1,492 @@
+import { S as runtimeOwnedScopeOwnerRuntime, _ as runtimeOwnedDriveHarnessProviderEvidence, b as runtimeOwnedExecutorProviderEvidence, d as recordRuntimeOwnedDriveHarnessProviderEvidence, i as attestRuntimeOwnedScopeOwner, s as inheritRuntimeOwnedExecutorAttestation, v as runtimeOwnedExecutorExecutionBinding, x as runtimeOwnedPendingExecutorMaterialization, y as runtimeOwnedExecutorMaterialization } from "./materialization-Bo6j3Hg9.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError, o as NotFoundError, r as BackendTransportError, t as AgentEvalError$1 } from "./errors-CDZ8XsVj.js";
 import { t as detachedSnapshot } from "./snapshot-cK9K420n.js";
-import { S as contentAddress, b as parseWorkerToolTraceArtifact, d as prepareJsonlAppend, f as writeAllBytes, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as parseCommittedJsonLines, x as workerTraceAnalysisStore } from "./spawn-journal-D2HKUImC.js";
-import { n as chargedTokens } from "./util-C1bv6yog.js";
-import { S as runtimeOwnedScopeOwnerRuntime, _ as runtimeOwnedDriveHarnessProviderEvidence, b as runtimeOwnedExecutorProviderEvidence, d as recordRuntimeOwnedDriveHarnessProviderEvidence, i as attestRuntimeOwnedScopeOwner, s as inheritRuntimeOwnedExecutorAttestation, v as runtimeOwnedExecutorExecutionBinding, x as runtimeOwnedPendingExecutorMaterialization, y as runtimeOwnedExecutorMaterialization } from "./materialization-P86EciBw.js";
-import { a as concreteProfileModel, d as harnessRunsAgent, n as assertModelAllowed, r as assertProfileModelsAllowed, s as profileModelExecutionSettings, t as assertExecutableAgentProfile, u as agentHarness } from "./model-policy-DgRJIJse.js";
-import { $ as createInbox, B as WORKER_TRACE_PROPAGATION, D as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Et as buildLoopSpanNodes, I as createExecutor, It as toOtelAttributes, L as createExecutorRegistry, M as bindReusableExecutorExecutionId, Mt as generateSpanId, N as bridgeStopSignalKey, O as teardownExecutor, P as captureReusableExecutorConfig, R as snapshotExecutorConfig, _t as runBrainLoop, a as pickBestDelivered, an as promptControlProfileMaterialization, c as driverChild, d as deriveNodeExecutionIdentity, en as assertProfileMaterialization, f as meterRuntimeOwnedAccounting, fn as worktreeCliProfileMaterialization, gt as routerBrain, h as scopeOwnerExecutorNodeContext, in as profileMaterializationAxes$1, it as createPeerMailbox, j as spendFromUsageEvents, k as assertValidBudget, kt as createOtelExporter, l as withDriverExecutor, m as recordScopeOwnerMaterialization, n as createSupervisor, nn as defineProfileMaterializationContract, o as runFinalizer, on as promptModelProfileMaterialization, p as meterRuntimeOwnedProviderAttempt, r as bestDelivered, rn as fullProfileMaterialization, s as runTree, tn as controlProfileMaterialization, w as freeSlots } from "./supervisor-s8SfZYbW.js";
+import { S as contentAddress, b as parseWorkerToolTraceArtifact, d as prepareJsonlAppend, f as writeAllBytes, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore, u as parseCommittedJsonLines, x as workerTraceAnalysisStore } from "./spawn-journal-CLguaA2A.js";
+import { r as chargedTokens } from "./util-Bncw0o_F.js";
+import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, f as harnessRunsAgent, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile } from "./model-policy-Sw4ywhtL.js";
+import { B as createExecutorRegistry, D as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, F as bridgeRuntimeAttachmentsKey, Ft as generateSpanId, I as bridgeStopSignalKey, L as captureReusableExecutorConfig, M as bindReusableExecutorExecutionId, Mt as createOtelExporter, N as bridgeAdmissionRead, O as teardownExecutor, P as bridgeModelRouteRefusal, U as WORKER_TRACE_PROPAGATION, V as snapshotExecutorConfig, _n as worktreeCliProfileMaterialization, a as pickBestDelivered, an as defineProfileMaterializationContract, bt as runBrainLoop, c as driverChild, cn as promptControlProfileMaterialization, d as deriveNodeExecutionIdentity, f as meterRuntimeOwnedAccounting, h as scopeOwnerExecutorNodeContext, hn as unsupportedProfileDimensions, in as controlProfileMaterialization, j as spendFromUsageEvents, k as assertValidBudget, kt as buildLoopSpanNodes, l as withDriverExecutor, ln as promptModelProfileMaterialization, m as recordScopeOwnerMaterialization, n as createSupervisor, nt as createInbox, o as runFinalizer, on as fullProfileMaterialization, p as meterRuntimeOwnedProviderAttempt, pn as renderUnsupported, r as bestDelivered, rn as assertProfileMaterialization, s as runTree, sn as profileMaterializationAxes$1, st as createPeerMailbox, t as createRootHandle, w as freeSlots, yt as routerBrain, z as createExecutor, zt as toOtelAttributes } from "./supervisor-DBVlPONC.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { _ as writeWorkerCancellation, a as readWorkerCancellation, i as readWorkerCancelRequests } from "./run-layout-Be_Z0dF8.js";
+import { C as writeWorkerCancellation, S as writeRunCancellation, a as readRunCancelRequest, c as readWorkerCancellation, o as readRunCancellation, s as readWorkerCancelRequests } from "./run-layout-C2jgwsCq.js";
 import { t as createStdioToolServer } from "./tool-server-DEmLr9YY.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
 import { randomUUID } from "node:crypto";
 import path, { dirname, join, resolve } from "node:path";
+import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { Readable, Writable } from "node:stream";
-//#region src/runtime/supervise/completion-gate.ts
+//#region src/runtime/supervise/detector-monitor.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.
+* The ONLINE analyst: watch a `TraceSource` and fold each tool span through agent-eval's published
+* streaming detector kernel (`repeatedActionDetector`/`errorStreakDetector` — the SAME kernel the
+* control loop folds), firing `onSignal` the moment a worker loops or error-storms. Substrate-
+* agnostic: it consumes spans from any source (owned router/bridge loop OR a sandbox box session),
+* never the raw tool seam. Detection logic + the failure taxonomy live in agent-eval; not reimplemented.
 *
 * @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
-* executor has produced its output. The inner `score` is preserved; only `valid` is gated.
-*/
-function gateOnDeliverable(inner, deliverable) {
-	let gated;
-	const check = async (out, baseScore) => {
-		let delivered;
+/** The default online panel for a tool-call pipe: a worker repeating the same call, or hammering
+*  consecutive errors. (No-progress needs a domain progress-probe, so it is opt-in, not default.)
+*
+*  Coverage note: `repeated-action` works for EVERY harness (it needs only tool name + args, which
+*  every adapter provides). `error-streak` needs per-call status — opencode carries it inline
+*  (`state.status`, VALIDATED live), but claude-code/codex tool-call parts do NOT (their errors live
+*  in separate result blocks not yet decoded), so error-streak is silent for those until result-block
+*  decoding is added + live-validated. It is in the panel because it is correct where status exists. */
+function defaultToolDetectors() {
+	return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
+}
+/** Subscribe to a `TraceSource` and run the streaming detectors over its live spans. Returns an
+*  unsubscribe. A defensive `argHash` failure (circular args) never throws out of the side-channel. */
+function watchTrace(source, opts = {}) {
+	const detectors = opts.detectors ?? defaultToolDetectors();
+	return source.onSpan((span) => {
+		let fingerprint;
 		try {
-			delivered = await deliverable.check(out) === true;
+			fingerprint = `${span.toolName}|${argHash(span.args)}`;
 		} catch {
-			delivered = false;
+			fingerprint = `${span.toolName}|<unhashable>`;
 		}
-		return {
-			valid: delivered,
-			score: baseScore ?? (delivered ? 1 : 0)
-		};
-	};
-	/**
-	* 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;
+		const signals = observeAll(detectors, {
+			actionFingerprint: fingerprint,
+			...span.status ? { status: span.status } : {},
+			label: span.toolName
+		});
+		for (const s of signals) opts.onSignal?.(s, span);
+	});
+}
+//#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.
+* @experimental In-process queue; durability is a transport swap that does not exist yet. */
+function createEventBus(now = Date.now) {
+	const queue = [];
+	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) => {
+		let best = -1;
+		let bestPriority = Number.NEGATIVE_INFINITY;
+		for (let i = 0; i < queue.length; i++) {
+			const r = queue[i];
+			if (!r || !matches(r, kinds)) continue;
+			if (r.priority > bestPriority) {
+				best = i;
+				bestPriority = r.priority;
+			}
 		}
-		gated = await check(art.out, art.verdict?.score);
+		return best;
 	};
-	return inheritRuntimeOwnedExecutorAttestation(inner, {
-		runtime: inner.runtime,
-		...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
-		...inner.deliver ? { deliver: (m) => inner.deliver?.(m) } : {},
-		...inner.progress ? { progress: () => inner.progress?.() } : {},
-		...inner.traceSource ? { traceSource: () => inner.traceSource?.() } : {},
-		...inner.metered ? { metered: () => inner.metered?.() } : {},
-		execute(task, signal) {
-			const r = inner.execute(task, signal);
-			if (isAsyncIterable$1(r)) return (async function* () {
-				try {
-					for await (const ev of r) yield ev;
-				} finally {
-					await settleVerdict();
-				}
-			})();
-			return (async () => {
-				let res;
-				try {
-					res = await r;
-				} catch (error) {
-					await settleVerdict();
-					throw error;
-				}
-				gated = await check(res.out, res.verdict?.score);
-				return {
-					...res,
-					verdict: gated
-				};
-			})();
+	return {
+		async publish(event, opts) {
+			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;
+			return record;
 		},
-		teardown: (grace) => inner.teardown(grace),
-		resultArtifact() {
-			const art = inner.resultArtifact();
+		pull(kinds) {
+			const i = bestIndex(kinds);
+			if (i < 0) return void 0;
+			pulled++;
+			return queue.splice(i, 1)[0]?.event;
+		},
+		subscribe(handler) {
+			subscribers.push(handler);
+			return () => {
+				const i = subscribers.indexOf(handler);
+				if (i >= 0) subscribers.splice(i, 1);
+			};
+		},
+		pending(kinds) {
+			return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
+		},
+		history() {
+			return log;
+		},
+		stats() {
 			return {
-				...art,
-				verdict: gated ?? art.verdict
+				published,
+				pulled,
+				byKind: { ...byKind }
 			};
 		}
-	});
-}
-/**
-* Transform a Runtime executor's terminal artifact without losing its private
-* profile-materialization attestation or altering its measured spend. This is
-* the composition point for deterministic post-processing and grading; callers
-* must not rebuild an Executor around a model transport merely to change `out`.
-*/
-function mapExecutorResult(inner, map) {
-	let mapped;
-	const settle = async (result, task) => {
-		const transformed = await map(result, task);
-		mapped = {
-			outRef: transformed.outRef,
-			out: transformed.out,
-			...transformed.verdict ? { verdict: transformed.verdict } : {},
-			spent: result.spent
-		};
-		return mapped;
 	};
-	return inheritRuntimeOwnedExecutorAttestation(inner, {
-		runtime: inner.runtime,
-		...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
-		...inner.deliver ? { deliver: (message) => inner.deliver?.(message) } : {},
-		...inner.progress ? { progress: () => inner.progress?.() } : {},
-		...inner.traceSource ? { traceSource: () => inner.traceSource?.() } : {},
-		...inner.accounting ? { accounting: () => inner.accounting?.() } : {},
-		...inner.metered ? { metered: () => inner.metered?.() } : {},
-		execute(task, signal) {
-			const execution = inner.execute(task, signal);
-			if (isAsyncIterable$1(execution)) return (async function* () {
-				for await (const event of execution) yield event;
-				await settle(inner.resultArtifact(), task);
-			})();
-			return (async () => settle(await execution, task))();
-		},
-		teardown: (grace) => inner.teardown(grace),
-		resultArtifact() {
-			if (!mapped) throw new Error("mapExecutorResult: resultArtifact() read before execute()");
-			return mapped;
-		}
-	});
-}
-function isAsyncIterable$1(v) {
-	return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 //#endregion
-//#region src/runtime/supervise/otel-spans.ts
+//#region src/mcp/tools/coordination.ts
 /**
-* Supervisor tree → OTLP spans. OPT-IN, off by default.
-*
-* WHY. A supervised tree is legible today only by parsing this package's own spawn journal, so
-* every other multi-agent shape on the machine (a coding-CLI's subagents, a pi fanout, ad-hoc tool
-* parallelism) needs its own bespoke reader. A span carrying `parent_span_id` IS a tree, and any
-* system can emit one — so emitting spans makes the supervisor readable by the same viewer as
-* everything else, with no per-system reader.
-*
-* WHAT IT IS NOT. This is telemetry, never the record of truth. The spawn journal remains the sole
-* durable ledger for replay/resume and for cost; nothing here is read back, and a run whose export
-* fails is unaffected in every observable way. The two data models are deliberately separate.
-*
-* HOW IT ATTACHES. This is a pure `RuntimeHooks` observer over the lifecycle events `Scope` ALREADY
-* emits — `agent.spawn` (a node opened), `agent.child` (a node settled), `agent.turn` (a driver
-* inference turn was metered). It adds no event, mutates no journal, and changes no result. Because
-* `Scope` re-seeds the same hooks into every nested scope (`makeNestedScopeSeam`), one observer sees
-* the WHOLE recursion at arbitrary depth.
 *
-* SPAN SHAPE. One span per supervised node, opened at spawn and closed at settle, parented to its
-* parent node's span; the run root is the trace. Driver inference rides as an `LLM` child span under
-* the node that metered it. Attributes reuse the vocabulary the rest of the stack already reads
-* (`openinference.span.kind`, `agent.name`, `llm.token_count.*`, `llm.cost_usd`, `tangle.cost.usd`)
-* — see `@tangle-network/agent-eval`'s `src/trace/attribute-vocabulary.ts`, which is the consumer.
+* MCP binding for a live `Scope`. A sandbox driver gets the same small verbs
+* the in-process driver has: spawn, observe, await, steer, ask/answer, analyze,
+* and stop. Settled outputs remain Scope artifacts; product code can project
+* them into any UI/report envelope it needs.
 *
-* UNKNOWN IS NEVER ZERO. `Spend.tokensKnown === false` / `usdKnown === false` mark work that
-* HAPPENED with an unreported count. Those spans OMIT the token/cost attribute entirely and set
-* `tangle.supervise.tokens_known` / `tangle.supervise.cost_known` to `false`, so a reader can never
-* mistake an unmeasured turn for a free one.
-*/
-/** OTEL status codes (`UNSET` / `OK` / `ERROR`) — the numeric wire values `OtelSpan.status` carries. */
-const STATUS_UNSET = 0;
-const STATUS_OK = 1;
-const STATUS_ERROR = 2;
-/** Longest string attribute value written from free-form detail, so an oversized turn payload
-*  cannot inflate a span. Identity/label attributes we control are never truncated. */
-const MAX_DETAIL_CHARS = 256;
-/**
-* Build the span recorder for one supervised run, or `undefined` when no exporter resolves — the
-* off-by-default path. A run that passes no `exporter` and no `exportConfig` never reaches this
-* function at all; one that passes an `exportConfig` with no endpoint (and no env endpoint) gets
-* `undefined` here, so "configured but unreachable" also costs nothing.
+* @experimental
 */
-function createSupervisorSpanRecorder(opts) {
-	const exporter = opts.exporter ?? createOtelExporter(opts.exportConfig);
-	if (!exporter) return void 0;
-	const ownsExporter = opts.exporter === void 0;
-	const now = opts.now ?? Date.now;
-	const traceId = normalizeTraceId(opts.traceId, opts.runId);
-	const rootSpanId = generateSpanId();
-	const rootStartMs = now();
-	const base = {
-		"tangle.run.id": opts.runId,
-		"tangle.sessionId": opts.runId,
-		...opts.attributes ?? {}
-	};
-	/** Node id → its open span. Seeded with the run id ⇒ the root span, because a depth-0 spawn's
-	*  `parentId` is the run id itself and every deeper spawn's is a real node id. */
-	const open = /* @__PURE__ */ new Map();
-	const spanIdOf = /* @__PURE__ */ new Map([[opts.runId, rootSpanId]]);
-	let finished = false;
-	/** Every export is best-effort: a throwing exporter must never reach the run. */
-	const emit = (span) => {
-		try {
-			exporter.exportSpan(span);
-		} catch {}
-	};
-	const span = (spanId, parentSpanId, name, startMs, endMs, attrs, status, message) => ({
-		traceId,
-		spanId,
-		...parentSpanId ? { parentSpanId } : {},
-		name,
-		kind: 1,
-		startTimeUnixNano: msToNano(startMs),
-		endTimeUnixNano: msToNano(Math.max(startMs, endMs)),
-		attributes: toOtelAttributes(attrs),
-		status: {
-			code: status,
-			...message ? { message } : {}
-		}
-	});
-	function onSpawn(event) {
-		const p = record(event.payload);
-		const childId = str(p.childId);
-		if (!childId) return;
-		const label = str(p.label) ?? "node";
-		const runtime = str(p.runtime);
-		const isWait = runtime === "wait";
-		const attrs = {
-			...base,
-			"openinference.span.kind": isWait ? "CHAIN" : "AGENT",
-			"agent.name": label,
-			"tangle.supervise.node.id": childId,
-			"tangle.supervise.node.label": label,
-			"tangle.supervise.node.kind": isWait ? "wait" : "agent",
-			"tangle.supervise.tree.root": event.runId
-		};
-		if (event.parentId) attrs["tangle.supervise.node.parent_id"] = event.parentId;
-		if (runtime) attrs["tangle.supervise.node.runtime"] = runtime;
-		if (typeof p.depth === "number") attrs["tangle.supervise.node.depth"] = p.depth;
-		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.ordinal"] = event.stepIndex;
-		if (p.resumed === true) attrs["tangle.supervise.node.resumed"] = true;
-		assignBudget(attrs, p.budget);
-		const spanId = generateSpanId();
-		spanIdOf.set(childId, spanId);
-		open.set(childId, {
-			spanId,
-			parentSpanId: event.parentId && spanIdOf.get(event.parentId) || rootSpanId,
-			name: label,
-			startMs: event.timestamp,
-			attrs
-		});
+/** Producer-side cleanliness for the `finding` event. The findings payload is arbitrary analyst
+*  output, the digest a subscriber computes (RFC 8785) throws on ANY `undefined` value — nested
+*  included — and a throwing subscriber leaves the event invisible to EVERY subscriber. The
+*  producer, not the digest, owns keeping the event canonical: an `undefined` payload is stripped
+*  to key-absence, everything else is JSON round-tripped (nested `undefined` object values drop,
+*  `undefined` array slots become `null`), and a payload JSON cannot represent at all (cycle,
+*  BigInt, bare function) becomes a record OF that fact — degraded findings beat a vanished
+*  event. */
+function canonicalFindingEvent(finding) {
+	if (finding.findings === void 0) {
+		const { findings: _absent, ...present } = finding;
+		return present;
 	}
-	function onSettled(event) {
-		const p = record(event.payload);
-		const childId = str(p.childId);
-		if (!childId) return;
-		const node = open.get(childId);
-		if (!node) return;
-		open.delete(childId);
-		const status = str(p.status);
-		const down = status === "down";
-		const attrs = {
-			...node.attrs,
-			"tangle.supervise.node.status": status ?? "done"
+	try {
+		return {
+			...finding,
+			findings: JSON.parse(JSON.stringify(finding.findings))
 		};
-		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.seq"] = event.stepIndex;
-		if (typeof p.outRef === "string") attrs["tangle.supervise.node.out_ref"] = p.outRef;
-		if (typeof p.valid === "boolean") attrs["tangle.supervise.verdict.valid"] = p.valid;
-		if (typeof p.score === "number") attrs["tangle.supervise.verdict.score"] = p.score;
-		if (down) {
-			attrs["error.type"] = p.infra === true ? "infra" : "child-down";
-			const reason = str(p.reason);
-			if (reason) attrs["error.message"] = truncate(reason);
-			if (typeof p.infra === "boolean") attrs["tangle.supervise.node.infra"] = p.infra;
-		}
-		const wokeBy = str(record(p.wait).settled);
-		if (wokeBy) attrs["tangle.supervise.wait.settled"] = wokeBy;
-		assignSpend(attrs, p.spent);
-		emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, event.timestamp, attrs, down ? STATUS_ERROR : STATUS_OK, down ? str(p.reason) ?? "child down" : void 0));
-	}
-	function onTurn(event) {
-		const p = record(event.payload);
-		const parentId = event.parentId;
-		const parentSpanId = parentId && spanIdOf.get(parentId) || rootSpanId;
-		const attrs = {
-			...base,
-			"openinference.span.kind": "LLM",
-			"inference.observation_kind": "LLM",
-			"tangle.supervise.node.kind": "inference"
+	} catch (error) {
+		return {
+			...finding,
+			findings: { nonCanonicalFindings: error instanceof Error ? error.message : String(error) }
 		};
-		if (parentId) attrs["tangle.supervise.node.id"] = parentId;
-		for (const [key, value] of Object.entries(p)) {
-			if (key === "spend") continue;
-			if (key === "driver" && typeof value === "string") {
-				attrs["agent.name"] = value;
-				attrs["inference.agent_name"] = value;
-				continue;
-			}
-			if (key === "model" && typeof value === "string") {
-				attrs["llm.model_name"] = value;
-				continue;
-			}
-			if (Array.isArray(value)) {
-				const scalars = value.filter((v) => typeof v === "string" || typeof v === "number");
-				if (scalars.length > 0) attrs[`tangle.supervise.turn.${key}`] = truncate(scalars.join(","));
-				continue;
-			}
-			if (typeof value === "string") attrs[`tangle.supervise.turn.${key}`] = truncate(value);
-			else if (typeof value === "number" || typeof value === "boolean") attrs[`tangle.supervise.turn.${key}`] = value;
-		}
-		const spend = assignSpend(attrs, p.spend);
-		const endMs = event.timestamp + (spend?.ms ?? 0);
-		emit(span(generateSpanId(), parentSpanId, "gen_ai.client.inference", event.timestamp, endMs, attrs, STATUS_OK));
-	}
-	return {
-		hooks: { onEvent(event) {
-			if (finished) return;
-			try {
-				if (event.phase !== "after") return;
-				if (event.target === "agent.spawn") onSpawn(event);
-				else if (event.target === "agent.child") onSettled(event);
-				else if (event.target === "agent.turn") onTurn(event);
-			} catch {}
-		} },
-		traceId,
-		rootSpanId,
-		workerTrace(spawningNodeId) {
-			return {
-				traceId,
-				parentSpanId: spanIdOf.get(spawningNodeId) ?? rootSpanId
-			};
-		},
-		async finish(outcome) {
-			if (finished) return;
-			finished = true;
-			const endMs = now();
-			try {
-				for (const [nodeId, node] of open) emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, endMs, {
-					...node.attrs,
-					"tangle.supervise.node.status": "unsettled",
-					"tangle.supervise.node.settled": false,
-					"tangle.supervise.node.id": nodeId
-				}, STATUS_UNSET));
-				open.clear();
-				emit(span(rootSpanId, opts.parentSpanId, "supervisor.run", rootStartMs, endMs, rootAttrs(base, opts.agentName ?? "supervisor", outcome), rootStatus(outcome), rootMessage(outcome)));
-				await exporter.flush();
-				if (ownsExporter) await exporter.shutdown();
-			} catch {}
-		}
-	};
-}
-function rootAttrs(base, agentName, outcome) {
-	const attrs = {
-		...base,
-		"openinference.span.kind": "AGENT",
-		"inference.observation_kind": "AGENT",
-		"agent.name": agentName,
-		"inference.agent_name": agentName,
-		"tangle.supervise.node.kind": "root"
-	};
-	const result = outcome?.result;
-	if (result) {
-		attrs["tangle.supervise.result"] = result.kind;
-		if (result.kind === "no-winner") {
-			attrs["tangle.supervise.reason"] = result.reason;
-			attrs["tangle.supervise.down_count"] = result.downCount;
-			if (result.reason === "driver-failed") {
-				attrs["error.type"] = result.error.name;
-				attrs["error.message"] = truncate(result.error.message);
-			}
-		}
-		assignSpend(attrs, result.spentTotal);
-	}
-	if (outcome?.error !== void 0) {
-		attrs["tangle.supervise.result"] = "error";
-		const err = outcome.error;
-		attrs["error.type"] = err instanceof Error ? err.name : typeof err;
-		attrs["error.message"] = truncate(err instanceof Error ? err.message : String(err));
 	}
-	return attrs;
 }
-function rootStatus(outcome) {
-	if (outcome?.error !== void 0) return STATUS_ERROR;
-	if (!outcome?.result) return STATUS_UNSET;
-	return outcome.result.kind === "winner" ? STATUS_OK : STATUS_ERROR;
+/** Normalize the two spellings of an analyst-on-settle entry to the route form. */
+function normalizeAnalyzeOnSettle(entry) {
+	return typeof entry === "string" ? { kind: entry } : entry;
 }
-function rootMessage(outcome) {
-	if (outcome?.error !== void 0) return truncate(outcome.error instanceof Error ? outcome.error.message : String(outcome.error));
-	const result = outcome?.result;
-	return result && result.kind === "no-winner" ? result.reason : void 0;
-}
-/**
-* Write a `Spend` onto a span, honouring the "a missing measurement is never zero" invariant: a
-* channel marked NOT known contributes no number at all and instead flags itself, so nothing
-* downstream can sum an unmeasured turn as free. Returns the spend it read (for the duration).
-*/
-function assignSpend(attrs, value) {
-	if (!isRecord(value)) return void 0;
-	const spend = value;
-	const tokens = isRecord(spend.tokens) ? spend.tokens : void 0;
-	if (spend.tokensKnown === false) attrs["tangle.supervise.tokens_known"] = false;
-	else if (tokens) {
-		if (typeof tokens.input === "number") attrs["llm.token_count.prompt"] = tokens.input;
-		if (typeof tokens.output === "number") attrs["llm.token_count.completion"] = tokens.output;
-	}
-	if (spend.usdKnown === false) attrs["tangle.supervise.cost_known"] = false;
-	else if (typeof spend.usd === "number" && Number.isFinite(spend.usd)) {
-		attrs["llm.cost_usd"] = spend.usd;
-		attrs["tangle.cost.usd"] = spend.usd;
-	}
-	if (typeof spend.iterations === "number") attrs["tangle.supervise.iterations"] = spend.iterations;
-	if (typeof spend.ms === "number" && spend.ms > 0) attrs["tangle.supervise.duration_ms"] = spend.ms;
-	return spend;
-}
-function assignBudget(attrs, value) {
-	if (!isRecord(value)) return;
-	const budget = value;
-	if (typeof budget.maxTokens === "number") attrs["tangle.supervise.budget.max_tokens"] = budget.maxTokens;
-	if (typeof budget.maxIterations === "number") attrs["tangle.supervise.budget.max_iterations"] = budget.maxIterations;
-	if (typeof budget.maxUsd === "number") attrs["tangle.supervise.budget.max_usd"] = budget.maxUsd;
+/** Every cause at zero — a pre-flight publishes its whole ledger from the first read. */
+function emptyPreflightCounts() {
+	return {
+		"model-route": 0,
+		"bridge-full": 0,
+		"unmountable-tool": 0
+	};
 }
+/** Default ceiling for a single `await_event` block (ms). Chosen well under any reasonable remote
+*  MCP client request timeout so the call returns a `pending` liveness snapshot instead of erroring;
+*  the supervisor re-polls until the worker settles. */
+const DEFAULT_AWAIT_EVENT_TIMEOUT_MS = 15e3;
+/** The reserved coordination verb names — the complete set `createCoordinationTools` can emit
+*  (the analyst pair is conditional but still reserved). A driver's extra WORK tools must not
+*  collide with any of these, or it could no longer coordinate; callers validate eagerly against
+*  this set so the conflict fails loud at construction, not buried in a swallowed `act()` throw. */
+const coordinationVerbNames = [
+	"spawn_agent",
+	"observe_agent",
+	"steer_agent",
+	"await_event",
+	"list_questions",
+	"answer_question",
+	"ask_parent",
+	"submit_result",
+	"stop",
+	"list_analysts",
+	"run_analyst"
+];
+const idArg = {
+	type: "string",
+	description: "The workerId returned by spawn_agent."
+};
 /**
-* A trace id must be 32 hex characters. A caller-supplied one is used verbatim when it already is;
-* anything else (and the default) is DERIVED from the run id by content address — deterministic, so
-* a resumed run rejoins the trace its first process opened rather than forking a new one.
+* Strip zod's object-KEY CODEC artifact from a derived JSON Schema, at every depth.
+*
+* `z.record(z.string(), …)` converts to `propertyNames: { type: 'string', pattern:
+* '^u(?:[0-9a-f]{4})*$' }` — a marker of the lossy key round-trip, not a constraint anything
+* enforces: `agentProfileSchema.safeParse({ name: 'r', tools: { bash: true, Read: false } })`
+* succeeds with those plain keys. Published verbatim it reads to a model as "every key must be a
+* run of hex quads", and the model either emits hex-encoded garbage keys or drops the field —
+* on `tools`, `permissions`, `metadata`, `mcp`, `mcp.*.env`, and `model.metadata`, which is most
+* of what a parent actually configures.
+*
+* Every `propertyNames` in the canonical profile schema is this artifact (25 of 25 at Interface
+* 0.40), and the canonical schema constrains no key by pattern, so dropping the keyword outright
+* loses nothing real and cannot be defeated by zod changing the encoding's exact regex.
+*
+* Rebuilds rather than mutates: the canonical conversion output must stay untouched for callers
+* that compare against it.
 */
-function normalizeTraceId(traceId, runId) {
-	if (traceId && /^[0-9a-f]{32}$/i.test(traceId)) return traceId.toLowerCase();
-	return contentAddress(traceId ?? runId).slice(7, 39);
-}
-function msToNano(ms) {
-	return (BigInt(Number.isFinite(ms) ? Math.floor(ms) : 0) * 1000000n).toString();
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function record(value) {
-	return isRecord(value) ? value : {};
-}
-function str(value) {
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function truncate(value) {
-	return value.length > MAX_DETAIL_CHARS ? `${value.slice(0, MAX_DETAIL_CHARS)}…` : value;
-}
-//#endregion
-//#region src/runtime/supervise/coordination-log.ts
+const stripKeyCodecArtifacts = (node) => {
+	if (Array.isArray(node)) return node.map(stripKeyCodecArtifacts);
+	if (!node || typeof node !== "object") return node;
+	return Object.fromEntries(Object.entries(node).filter(([key]) => key !== "propertyNames").map(([key, value]) => [key, stripKeyCodecArtifacts(value)]));
+};
+/** The canonical profile fields a spawning parent actually sets on a child, in the order a reader
+*  needs them, each with the description published alongside it. Everything else stays legal to
+*  pass — see {@link deriveSpawnProfileArg}.
+*
+*  Why these eleven, with the measured numbers (serialized JSON bytes, Interface 0.40). The
+*  canonical `properties` map is 10629 bytes, against 2424 bytes for every argument of every other
+*  coordination tool COMBINED — publishing it whole makes one parameter four times the rest of the
+*  surface a driver re-reads each turn. Of the seven omitted fields (tags, connections, subagents,
+*  hooks, modes, confidential, extensions) none is something a parent hands a worker; `permissions`
+*  (321 bytes) IS, so it is published — a child that must not touch the network or the filesystem
+*  is fenced there and nowhere else. `mcp` (2663 bytes) and `resources` (3122 bytes) are the two a
+*  parent is least likely to author inline and were together 85% of the published cost, so they
+*  carry a brief shape plus a description naming the full form instead of the canonical sub-tree. */
+const spawnProfileFields = [
+	{
+		name: "name",
+		description: "Short identifier for this child, e.g. \"researcher\" or \"patch-writer\". A child normally sets it to its role; it shows up in traces and worker labels."
+	},
+	{
+		name: "description",
+		description: "One line saying what this child is for. Read by humans and by a parent listing its workers."
+	},
+	{
+		name: "version",
+		description: "Optional version string for this profile, so two revisions of the same role are distinguishable in evidence. A child usually omits it."
+	},
+	{
+		name: "harness",
+		description: "Which coding backend runs the child. Omit to inherit the run default; set it only when this child needs a specific backend (e.g. a long refactor on \"claude-code\")."
+	},
+	{
+		name: "model",
+		description: "Model routing: `default` model id, optional `small` for cheap sub-calls, `provider`, and `reasoningEffort`. A child typically sets `default` and `reasoningEffort` — raise effort for a hard reasoning task, lower it for bulk mechanical work."
+	},
+	{
+		name: "prompt",
+		description: "The child's standing instructions: `systemPrompt` (who it is and how it works) and `instructions` (durable rules). This is the role; the separate `task` argument carries what to do right now. A child with no systemPrompt has no role — always set one."
+	},
+	{
+		name: "tools",
+		description: "Per-tool on/off map keyed by tool name, e.g. `{ \"bash\": true, \"webfetch\": false }`. Omit to inherit the backend's default tool set; set it to narrow a child to the tools its task needs. Keys are plain tool names."
+	},
+	{
+		name: "permissions",
+		description: "Per-tool permission decisions: each tool name maps to \"allow\", \"deny\", or \"ask\", or to a nested map of finer-grained rules. This is where a parent fences a child it does not fully trust — a read-only child denies write and network tools here, not in `tools`."
+	},
+	{
+		name: "mcp",
+		description: "MCP tool servers to mount for the child, keyed by server name. Brief form: each value is either `{ transport: \"stdio\", command, args?, env?, cwd? }` or `{ transport: \"sse\" | \"http\", url, headers? }`. A child normally sets this only when it needs a tool server the task requires; the canonical AgentProfile schema carries the full form (secret-ref values for env/headers, per-server metadata) and governs validation.",
+		brief: {
+			type: "object",
+			additionalProperties: { type: "object" }
+		}
+	},
+	{
+		name: "resources",
+		description: "Files, tools, skills, and agents materialized into the child workspace before it starts. Brief form: `{ files?, tools?, skills?, agents? }`, each an array whose entries are `{ kind: \"inline\", name, content }` or `{ kind: \"github\", repository?, path, ref? }` (`files` entries wrap that as `{ path, resource, executable? }`). A child typically gets `files` for seed inputs and `skills` for a procedure it must follow; the canonical AgentProfile schema carries the full form and governs validation.",
+		brief: {
+			type: "object",
+			properties: {
+				files: {
+					type: "array",
+					items: { type: "object" }
+				},
+				tools: {
+					type: "array",
+					items: { type: "object" }
+				},
+				skills: {
+					type: "array",
+					items: { type: "object" }
+				},
+				agents: {
+					type: "array",
+					items: { type: "object" }
+				}
+			},
+			additionalProperties: true
+		}
+	},
+	{
+		name: "metadata",
+		description: "Free-form key/value bag carried with the profile (plain string keys). Use it for run bookkeeping a reader will want later; it does not change how the child executes."
+	}
+];
 /**
-* 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.
+* Build the published shape of `spawn_agent`'s `profile` argument from the canonical
+* `agentProfileSchema` conversion's `properties` map, so it cannot drift from the profile the
+* runtime materializes.
 *
-* 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.
+* DEGRADES, never throws. A canonical field that is absent — renamed or removed upstream — is
+* simply omitted from the published shape, and a canonical schema that is no longer an object
+* publishes no properties at all. This function is reached from a statically-imported module, so a
+* throw here bricks `import '@tangle-network/agent-runtime/kernel'` for every consumer over an
+* upstream rename that costs them, at worst, one advisory field. The drift itself is still caught
+* loudly — as a test assertion in `tests/kernel/coordination.test.ts`, in CI, where it is our
+* problem rather than at a consumer's import, where it is theirs.
 *
-* JSONL, one fsynced record per event, keyed by `runId` — several runs may share one log file
-* exactly as they share one spawn-journal file.
+* Permissive on purpose: `additionalProperties: true` with no `required` list, so every canonical
+* field this shape omits stays legal to pass. This tool layer performs no profile validation.
 *
-* @experimental
+* @internal exported for the drift and degradation tests; not part of the package's public API.
 */
-/** Persist prior context plus exact continuation authorization, attempt, and result evidence.
-* Settlements have their own journal. */
-function persisted(event) {
-	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, 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,
-			...ownerId !== void 0 ? { ownerId } : {},
-			...busRecord
-		};
-		const needsSeparator = await prepareJsonlAppend(this.path);
-		const fh = await fs.open(this.path, "a");
-		try {
-			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
-			await fh.sync();
-		} finally {
-			await fh.close();
-		}
+function deriveSpawnProfileArg(canonicalProperties) {
+	const published = [];
+	for (const field of spawnProfileFields) {
+		const canonical = canonicalProperties?.[field.name];
+		if (canonical === void 0) continue;
+		const shape = field.brief ?? stripKeyCodecArtifacts(canonical);
+		published.push([field.name, {
+			...shape,
+			description: field.description
+		}]);
 	}
-	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 emptyPriorCoordination(ownerId);
-			throw err;
-		}
-		const byId = /* @__PURE__ */ new Map();
-		const findings = [];
-		const continuations = [];
-		const deliveryEvidence = [];
-		const mail = [];
-		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 && ev.down.delivered) byId.set(ev.questionId, {
-					...prior,
-					status: "answered",
-					decision: {
-						kind: "answer",
-						answer: ev.down.instruction,
-						by: "prior-run"
-					}
-				});
-			} else if (ev.type === "instruction") continuations.push(ev.instruction);
-			else if (ev.type === "mail") mail.push(ev.mail);
-		}
-		return {
-			...ownerId !== void 0 ? { ownerId } : {},
-			questions: [...byId.values()],
-			findings,
-			continuations,
-			deliveryEvidence,
-			mail,
-			records
-		};
-	}
-};
-function emptyPriorCoordination(ownerId) {
 	return {
-		...ownerId !== void 0 ? { ownerId } : {},
-		questions: [],
-		findings: [],
-		continuations: [],
-		deliveryEvidence: [],
-		mail: [],
-		records: []
+		type: "object",
+		description: "The child agent profile to run — this is the shape the DEFAULT worker seam accepts; a run wired with a custom makeWorkerAgent may accept a different one. The properties below are derived from the canonical AgentProfile schema and reduced to what a spawning parent sets (`mcp` and `resources` in a brief form); every other canonical field — tags, connections, subagents, hooks, modes, confidential, extensions — may still be passed. This tool does not validate the profile: the canonical AgentProfile schema governs validation downstream.",
+		properties: Object.fromEntries(published),
+		additionalProperties: true
 	};
 }
-function isNoEntError(err) {
-	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-//#endregion
-//#region src/runtime/supervise/run-context.ts
-/**
-*
-* `createInMemoryRunContext` — the one-call bundle of the in-memory stores a
-* `createSupervisor().run(root, task, opts)` needs: a fresh `InMemorySpawnJournal`
-* (the event-sourced spawn log), a fresh `InMemoryResultBlobStore` (the
-* content-addressed `outRef` payload store the driver's `observe`/`finalize` reads
-* settled outputs through), and a fresh `createExecutorRegistry()` (the open
-* `AgentSpec → Executor` resolver).
-*
-* It exists to kill the boilerplate every offline/local supervised run repeats by
-* hand — three constructors threaded into `SupervisorOpts` — and to single-source the
-* ONE wiring invariant that is easy to get wrong: when the root is the recursive
-* `driverAgent` LLM-driver brain AND it may spawn DRIVER children (agents
-* driving agents), the registry MUST be wrapped with `withDriverExecutor` so a
-* `role: 'driver'` child resolves to the nested-scope executor — and that SAME blob
-* store MUST be the one passed to `driverAgent({ blobs })`, or the driver
-* reads from a different store than the scope writes to. Pass `{ withDriver: true }`
-* and reuse the returned `blobs` for both.
-*
-* The spread shape matches `SupervisorOpts` exactly, so the call site reads:
-*   const run = createInMemoryRunContext()
-*   await createSupervisor().run(root, task, { budget, runId, ...run })
+spawnProfileFields.map((f) => f.name);
+let spawnProfileArgCache;
+/** The published `profile` shape, computed on FIRST tool-definition access and memoized — not at
+*  module load. The conversion walks the whole canonical profile tree, and the strip walk rebuilds
+*  it: 3.5ms on the first `createCoordinationTools`, 0.017ms on every later one (measured, Interface
+*  0.40, node 24). `src/runtime/index.ts` imports this module statically, so paying that at import
+*  taxes every consumer of the kernel entrypoint — including the ones that never build a
+*  coordination toolbox. The memo keeps it at once per process for the ones that do.
 *
-* @experimental
-*/
-/**
-* Build a fresh in-memory run context. Every call returns NEW stores (no shared global
-* state between runs), so two runs never cross-contaminate their journals/blobs.
-*/
-function createInMemoryRunContext(opts = {}) {
-	const base = createExecutorRegistry();
-	return {
-		journal: new InMemorySpawnJournal(),
-		blobs: new InMemoryResultBlobStore(),
-		executors: opts.withDriver ? withDriverExecutor(base) : base
-	};
+*  Conversion choices. `io: 'input'` is the CALLER's view — pre-default, pre-transform — which is
+*  what a spawning parent may pass, not what the runtime ends up holding. `unrepresentable: 'any'`
+*  keeps the conversion total: the canonical schema contains transforms with no JSON Schema form,
+*  and zod's default is to throw on them, which would leave the tool with no published shape. */
+function spawnProfileArg() {
+	if (!spawnProfileArgCache) spawnProfileArgCache = deepFreeze(deriveSpawnProfileArg(agentProfileSchema.toJSONSchema({
+		io: "input",
+		target: "draft-07",
+		unrepresentable: "any"
+	}).properties));
+	return spawnProfileArgCache;
 }
-/**
-* Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
-* per append/write) under `dir`, and the context carries `resume: true` so spreading it into
-* `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
-* resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
-* 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, 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.
-*/
-function createFileRunContext(dir, opts = {}) {
-	const base = createExecutorRegistry();
-	return {
-		journal: new FileSpawnJournal(`${dir}/spawn-journal.jsonl`),
-		blobs: new FileResultBlobStore(`${dir}/blobs`),
-		executors: opts.withDriver ? withDriverExecutor(base) : base,
-		resume: true,
-		coordinationLog: new FileCoordinationLog(`${dir}/coordination-log.jsonl`)
+/** Build the driver's MCP tools over a live scope. */
+function createCoordinationTools(opts) {
+	const deliverable = opts.deliverable;
+	let stopped = false;
+	let reason;
+	let stopNotified = false;
+	let submitted;
+	let questionSeq = 0;
+	const ledger = [];
+	const questions = [...opts.priorQuestions ?? []];
+	const questionPolicy = opts.questionPolicy ?? "auto";
+	const notifyStop = () => {
+		if (stopNotified) return;
+		stopNotified = true;
+		opts.onStop?.(reason);
 	};
-}
-//#endregion
-//#region src/runtime/supervise/detector-monitor.ts
-/**
-*
-* The ONLINE analyst: watch a `TraceSource` and fold each tool span through agent-eval's published
-* streaming detector kernel (`repeatedActionDetector`/`errorStreakDetector` — the SAME kernel the
-* control loop folds), firing `onSignal` the moment a worker loops or error-storms. Substrate-
-* agnostic: it consumes spans from any source (owned router/bridge loop OR a sandbox box session),
-* never the raw tool seam. Detection logic + the failure taxonomy live in agent-eval; not reimplemented.
-*
-* @experimental
-*/
-/** The default online panel for a tool-call pipe: a worker repeating the same call, or hammering
-*  consecutive errors. (No-progress needs a domain progress-probe, so it is opt-in, not default.)
-*
-*  Coverage note: `repeated-action` works for EVERY harness (it needs only tool name + args, which
-*  every adapter provides). `error-streak` needs per-call status — opencode carries it inline
-*  (`state.status`, VALIDATED live), but claude-code/codex tool-call parts do NOT (their errors live
-*  in separate result blocks not yet decoded), so error-streak is silent for those until result-block
-*  decoding is added + live-validated. It is in the panel because it is correct where status exists. */
-function defaultToolDetectors() {
-	return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
-}
-/** Subscribe to a `TraceSource` and run the streaming detectors over its live spans. Returns an
-*  unsubscribe. A defensive `argHash` failure (circular args) never throws out of the side-channel. */
-function watchTrace(source, opts = {}) {
-	const detectors = opts.detectors ?? defaultToolDetectors();
-	return source.onSpan((span) => {
-		let fingerprint;
-		try {
-			fingerprint = `${span.toolName}|${argHash(span.args)}`;
-		} catch {
-			fingerprint = `${span.toolName}|<unhashable>`;
-		}
-		const signals = observeAll(detectors, {
-			actionFingerprint: fingerprint,
-			...span.status ? { status: span.status } : {},
-			label: span.toolName
+	const completedKeys = /* @__PURE__ */ new Set();
+	const keyByWorker = /* @__PURE__ */ new Map();
+	const profileNameByWorker = /* @__PURE__ */ new Map();
+	const liveHandles = /* @__PURE__ */ new Map();
+	let unkeyedAssignmentOrdinal = nextUnkeyedAssignmentOrdinal(opts.scope);
+	const preflightCounts = emptyPreflightCounts();
+	for (const [key, prior] of opts.scope.resume?.keys ?? []) if (prior.state === "completed") completedKeys.add(key);
+	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
 		});
-		for (const s of signals) opts.onSignal?.(s, span);
-	});
-}
-//#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.
-* @experimental In-process queue; durability is a transport swap that does not exist yet. */
-function createEventBus(now = Date.now) {
-	const queue = [];
-	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) => {
-		let best = -1;
-		let bestPriority = Number.NEGATIVE_INFINITY;
-		for (let i = 0; i < queue.length; i++) {
-			const r = queue[i];
-			if (!r || !matches(r, kinds)) continue;
-			if (r.priority > bestPriority) {
-				best = i;
-				bestPriority = r.priority;
+	};
+	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, 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;
 			}
-		}
-		return best;
+		})().finally(() => {
+			readyInFlight = void 0;
+		});
+		return readyInFlight;
 	};
-	return {
-		async publish(event, opts) {
-			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;
-			return record;
-		},
-		pull(kinds) {
-			const i = bestIndex(kinds);
-			if (i < 0) return void 0;
-			pulled++;
-			return queue.splice(i, 1)[0]?.event;
-		},
-		subscribe(handler) {
-			subscribers.push(handler);
-			return () => {
-				const i = subscribers.indexOf(handler);
-				if (i >= 0) subscribers.splice(i, 1);
-			};
-		},
-		pending(kinds) {
-			return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
-		},
-		history() {
-			return log;
-		},
-		stats() {
-			return {
-				published,
-				pulled,
-				byKind: { ...byKind }
-			};
-		}
+	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`);
+		return v;
 	};
-}
-//#endregion
-//#region src/mcp/tools/coordination.ts
-/**
-*
-* MCP binding for a live `Scope`. A sandbox driver gets the same small verbs
-* the in-process driver has: spawn, observe, await, steer, ask/answer, analyze,
-* and stop. Settled outputs remain Scope artifacts; product code can project
-* them into any UI/report envelope it needs.
-*
-* @experimental
-*/
-/** Producer-side cleanliness for the `finding` event. The findings payload is arbitrary analyst
-*  output, the digest a subscriber computes (RFC 8785) throws on ANY `undefined` value — nested
-*  included — and a throwing subscriber leaves the event invisible to EVERY subscriber. The
-*  producer, not the digest, owns keeping the event canonical: an `undefined` payload is stripped
-*  to key-absence, everything else is JSON round-tripped (nested `undefined` object values drop,
-*  `undefined` array slots become `null`), and a payload JSON cannot represent at all (cycle,
-*  BigInt, bare function) becomes a record OF that fact — degraded findings beat a vanished
-*  event. */
-function canonicalFindingEvent(finding) {
-	if (finding.findings === void 0) {
-		const { findings: _absent, ...present } = finding;
-		return present;
-	}
-	try {
-		return {
-			...finding,
-			findings: JSON.parse(JSON.stringify(finding.findings))
+	const obj = (raw) => {
+		if (!raw || typeof raw !== "object") throw new Error("coordination tools: arguments must be an object");
+		return raw;
+	};
+	const mergeBudget = (base, raw) => {
+		if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("coordination tools: \"budget\" must be an object");
+		const o = raw;
+		const field = (name) => {
+			const v = o[name];
+			if (v === void 0) return void 0;
+			if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`coordination tools: "budget.${name}" must be a finite number`);
+			return v;
 		};
-	} catch (error) {
-		return {
-			...finding,
-			findings: { nonCanonicalFindings: error instanceof Error ? error.message : String(error) }
-		};
-	}
-}
-/** Normalize the two spellings of an analyst-on-settle entry to the route form. */
-function normalizeAnalyzeOnSettle(entry) {
-	return typeof entry === "string" ? { kind: entry } : entry;
-}
-/** Default ceiling for a single `await_event` block (ms). Chosen well under any reasonable remote
-*  MCP client request timeout so the call returns a `pending` liveness snapshot instead of erroring;
-*  the supervisor re-polls until the worker settles. */
-const DEFAULT_AWAIT_EVENT_TIMEOUT_MS = 15e3;
-/** The reserved coordination verb names — the complete set `createCoordinationTools` can emit
-*  (the analyst pair is conditional but still reserved). A driver's extra WORK tools must not
-*  collide with any of these, or it could no longer coordinate; callers validate eagerly against
-*  this set so the conflict fails loud at construction, not buried in a swallowed `act()` throw. */
-const coordinationVerbNames = [
-	"spawn_agent",
-	"observe_agent",
-	"steer_agent",
-	"await_event",
-	"list_questions",
-	"answer_question",
-	"ask_parent",
-	"submit_result",
-	"stop",
-	"list_analysts",
-	"run_analyst"
-];
-const idArg = {
-	type: "string",
-	description: "The workerId returned by spawn_agent."
-};
-/**
-* Strip zod's object-KEY CODEC artifact from a derived JSON Schema, at every depth.
-*
-* `z.record(z.string(), …)` converts to `propertyNames: { type: 'string', pattern:
-* '^u(?:[0-9a-f]{4})*$' }` — a marker of the lossy key round-trip, not a constraint anything
-* enforces: `agentProfileSchema.safeParse({ name: 'r', tools: { bash: true, Read: false } })`
-* succeeds with those plain keys. Published verbatim it reads to a model as "every key must be a
-* run of hex quads", and the model either emits hex-encoded garbage keys or drops the field —
-* on `tools`, `permissions`, `metadata`, `mcp`, `mcp.*.env`, and `model.metadata`, which is most
-* of what a parent actually configures.
-*
-* Every `propertyNames` in the canonical profile schema is this artifact (25 of 25 at Interface
-* 0.40), and the canonical schema constrains no key by pattern, so dropping the keyword outright
-* loses nothing real and cannot be defeated by zod changing the encoding's exact regex.
-*
-* Rebuilds rather than mutates: the canonical conversion output must stay untouched for callers
-* that compare against it.
-*/
-const stripKeyCodecArtifacts = (node) => {
-	if (Array.isArray(node)) return node.map(stripKeyCodecArtifacts);
-	if (!node || typeof node !== "object") return node;
-	return Object.fromEntries(Object.entries(node).filter(([key]) => key !== "propertyNames").map(([key, value]) => [key, stripKeyCodecArtifacts(value)]));
-};
-/** The canonical profile fields a spawning parent actually sets on a child, in the order a reader
-*  needs them, each with the description published alongside it. Everything else stays legal to
-*  pass — see {@link deriveSpawnProfileArg}.
-*
-*  Why these eleven, with the measured numbers (serialized JSON bytes, Interface 0.40). The
-*  canonical `properties` map is 10629 bytes, against 2424 bytes for every argument of every other
-*  coordination tool COMBINED — publishing it whole makes one parameter four times the rest of the
-*  surface a driver re-reads each turn. Of the seven omitted fields (tags, connections, subagents,
-*  hooks, modes, confidential, extensions) none is something a parent hands a worker; `permissions`
-*  (321 bytes) IS, so it is published — a child that must not touch the network or the filesystem
-*  is fenced there and nowhere else. `mcp` (2663 bytes) and `resources` (3122 bytes) are the two a
-*  parent is least likely to author inline and were together 85% of the published cost, so they
-*  carry a brief shape plus a description naming the full form instead of the canonical sub-tree. */
-const spawnProfileFields = [
-	{
-		name: "name",
-		description: "Short identifier for this child, e.g. \"researcher\" or \"patch-writer\". A child normally sets it to its role; it shows up in traces and worker labels."
-	},
-	{
-		name: "description",
-		description: "One line saying what this child is for. Read by humans and by a parent listing its workers."
-	},
-	{
-		name: "version",
-		description: "Optional version string for this profile, so two revisions of the same role are distinguishable in evidence. A child usually omits it."
-	},
-	{
-		name: "harness",
-		description: "Which coding backend runs the child. Omit to inherit the run default; set it only when this child needs a specific backend (e.g. a long refactor on \"claude-code\")."
-	},
-	{
-		name: "model",
-		description: "Model routing: `default` model id, optional `small` for cheap sub-calls, `provider`, and `reasoningEffort`. A child typically sets `default` and `reasoningEffort` — raise effort for a hard reasoning task, lower it for bulk mechanical work."
-	},
-	{
-		name: "prompt",
-		description: "The child's standing instructions: `systemPrompt` (who it is and how it works) and `instructions` (durable rules). This is the role; the separate `task` argument carries what to do right now. A child with no systemPrompt has no role — always set one."
-	},
-	{
-		name: "tools",
-		description: "Per-tool on/off map keyed by tool name, e.g. `{ \"bash\": true, \"webfetch\": false }`. Omit to inherit the backend's default tool set; set it to narrow a child to the tools its task needs. Keys are plain tool names."
-	},
-	{
-		name: "permissions",
-		description: "Per-tool permission decisions: each tool name maps to \"allow\", \"deny\", or \"ask\", or to a nested map of finer-grained rules. This is where a parent fences a child it does not fully trust — a read-only child denies write and network tools here, not in `tools`."
-	},
-	{
-		name: "mcp",
-		description: "MCP tool servers to mount for the child, keyed by server name. Brief form: each value is either `{ transport: \"stdio\", command, args?, env?, cwd? }` or `{ transport: \"sse\" | \"http\", url, headers? }`. A child normally sets this only when it needs a tool server the task requires; the canonical AgentProfile schema carries the full form (secret-ref values for env/headers, per-server metadata) and governs validation.",
-		brief: {
-			type: "object",
-			additionalProperties: { type: "object" }
-		}
-	},
-	{
-		name: "resources",
-		description: "Files, tools, skills, and agents materialized into the child workspace before it starts. Brief form: `{ files?, tools?, skills?, agents? }`, each an array whose entries are `{ kind: \"inline\", name, content }` or `{ kind: \"github\", repository?, path, ref? }` (`files` entries wrap that as `{ path, resource, executable? }`). A child typically gets `files` for seed inputs and `skills` for a procedure it must follow; the canonical AgentProfile schema carries the full form and governs validation.",
-		brief: {
-			type: "object",
-			properties: {
-				files: {
-					type: "array",
-					items: { type: "object" }
-				},
-				tools: {
-					type: "array",
-					items: { type: "object" }
-				},
-				skills: {
-					type: "array",
-					items: { type: "object" }
-				},
-				agents: {
-					type: "array",
-					items: { type: "object" }
-				}
-			},
-			additionalProperties: true
-		}
-	},
-	{
-		name: "metadata",
-		description: "Free-form key/value bag carried with the profile (plain string keys). Use it for run bookkeeping a reader will want later; it does not change how the child executes."
-	}
-];
-/**
-* Build the published shape of `spawn_agent`'s `profile` argument from the canonical
-* `agentProfileSchema` conversion's `properties` map, so it cannot drift from the profile the
-* runtime materializes.
-*
-* DEGRADES, never throws. A canonical field that is absent — renamed or removed upstream — is
-* simply omitted from the published shape, and a canonical schema that is no longer an object
-* publishes no properties at all. This function is reached from a statically-imported module, so a
-* throw here bricks `import '@tangle-network/agent-runtime/kernel'` for every consumer over an
-* upstream rename that costs them, at worst, one advisory field. The drift itself is still caught
-* loudly — as a test assertion in `tests/kernel/coordination.test.ts`, in CI, where it is our
-* problem rather than at a consumer's import, where it is theirs.
-*
-* Permissive on purpose: `additionalProperties: true` with no `required` list, so every canonical
-* field this shape omits stays legal to pass. This tool layer performs no profile validation.
-*
-* @internal exported for the drift and degradation tests; not part of the package's public API.
-*/
-function deriveSpawnProfileArg(canonicalProperties) {
-	const published = [];
-	for (const field of spawnProfileFields) {
-		const canonical = canonicalProperties?.[field.name];
-		if (canonical === void 0) continue;
-		const shape = field.brief ?? stripKeyCodecArtifacts(canonical);
-		published.push([field.name, {
-			...shape,
-			description: field.description
-		}]);
-	}
-	return {
-		type: "object",
-		description: "The child agent profile to run — this is the shape the DEFAULT worker seam accepts; a run wired with a custom makeWorkerAgent may accept a different one. The properties below are derived from the canonical AgentProfile schema and reduced to what a spawning parent sets (`mcp` and `resources` in a brief form); every other canonical field — tags, connections, subagents, hooks, modes, confidential, extensions — may still be passed. This tool does not validate the profile: the canonical AgentProfile schema governs validation downstream.",
-		properties: Object.fromEntries(published),
-		additionalProperties: true
-	};
-}
-spawnProfileFields.map((f) => f.name);
-let spawnProfileArgCache;
-/** The published `profile` shape, computed on FIRST tool-definition access and memoized — not at
-*  module load. The conversion walks the whole canonical profile tree, and the strip walk rebuilds
-*  it: 3.5ms on the first `createCoordinationTools`, 0.017ms on every later one (measured, Interface
-*  0.40, node 24). `src/runtime/index.ts` imports this module statically, so paying that at import
-*  taxes every consumer of the kernel entrypoint — including the ones that never build a
-*  coordination toolbox. The memo keeps it at once per process for the ones that do.
-*
-*  Conversion choices. `io: 'input'` is the CALLER's view — pre-default, pre-transform — which is
-*  what a spawning parent may pass, not what the runtime ends up holding. `unrepresentable: 'any'`
-*  keeps the conversion total: the canonical schema contains transforms with no JSON Schema form,
-*  and zod's default is to throw on them, which would leave the tool with no published shape. */
-function spawnProfileArg() {
-	if (!spawnProfileArgCache) spawnProfileArgCache = deepFreeze(deriveSpawnProfileArg(agentProfileSchema.toJSONSchema({
-		io: "input",
-		target: "draft-07",
-		unrepresentable: "any"
-	}).properties));
-	return spawnProfileArgCache;
-}
-/** Build the driver's MCP tools over a live scope. */
-function createCoordinationTools(opts) {
-	const deliverable = opts.deliverable;
-	let stopped = false;
-	let reason;
-	let stopNotified = false;
-	let submitted;
-	let questionSeq = 0;
-	const ledger = [];
-	const questions = [...opts.priorQuestions ?? []];
-	const questionPolicy = opts.questionPolicy ?? "auto";
-	const notifyStop = () => {
-		if (stopNotified) return;
-		stopNotified = true;
-		opts.onStop?.(reason);
-	};
-	const completedKeys = /* @__PURE__ */ new Set();
-	const keyByWorker = /* @__PURE__ */ new Map();
-	const profileNameByWorker = /* @__PURE__ */ new Map();
-	const liveHandles = /* @__PURE__ */ new Map();
-	let unkeyedAssignmentOrdinal = nextUnkeyedAssignmentOrdinal(opts.scope);
-	for (const [key, prior] of opts.scope.resume?.keys ?? []) if (prior.state === "completed") completedKeys.add(key);
-	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, 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`);
-		return v;
-	};
-	const obj = (raw) => {
-		if (!raw || typeof raw !== "object") throw new Error("coordination tools: arguments must be an object");
-		return raw;
-	};
-	const mergeBudget = (base, raw) => {
-		if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("coordination tools: \"budget\" must be an object");
-		const o = raw;
-		const field = (name) => {
-			const v = o[name];
-			if (v === void 0) return void 0;
-			if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`coordination tools: "budget.${name}" must be a finite number`);
-			return v;
-		};
-		const maxIterations = field("maxIterations");
-		const maxTokens = field("maxTokens");
-		const maxUsd = field("maxUsd");
-		const deadlineMs = field("deadlineMs");
-		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 }
+		const maxIterations = field("maxIterations");
+		const maxTokens = field("maxTokens");
+		const maxUsd = field("maxUsd");
+		const deadlineMs = field("deadlineMs");
+		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;
@@ -1809,7 +1174,7 @@ function createCoordinationTools(opts) {
 				},
 				required: ["profile", "task"]
 			},
-			handler: (raw) => {
+			handler: async (raw) => {
 				const a = obj(raw);
 				const key = a.key === void 0 ? void 0 : str(a.key, "key");
 				if (!(key !== void 0 && completedKeys.has(key)) && !usesTreeWideLimit() && maxLiveWorkers !== void 0 && maxLiveWorkers > 0 && liveWorkerCount() >= maxLiveWorkers) return Promise.resolve({
@@ -1835,6 +1200,23 @@ function createCoordinationTools(opts) {
 				});
 				const task = deepFreezeDetached(a.task);
 				const label = typeof a.label === "string" ? a.label : "worker";
+				if (opts.preflightSpawn) {
+					const refusal = await opts.preflightSpawn(profile, {
+						label,
+						...key !== void 0 ? { key } : {},
+						task
+					});
+					if (refusal) {
+						preflightCounts[refusal.cause] += 1;
+						return {
+							error: "preflight-refused",
+							cause: refusal.cause,
+							detail: refusal.detail,
+							live: liveWorkerCount(),
+							freeSlots: freeWorkerSlots()
+						};
+					}
+				}
 				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 peerMailUrl = peerMail?.mintCapability(assignmentId);
@@ -2262,63 +1644,711 @@ function createCoordinationTools(opts) {
 		if (handle === void 0) return void 0;
 		handle.abort(reason);
 		return {
-			id: target.id,
-			label: target.label
+			id: target.id,
+			label: target.label
+		};
+	};
+	return {
+		tools,
+		ready,
+		history: () => bus.history(),
+		raiseFinding: (finding) => bus.publish({
+			type: "finding",
+			finding: canonicalFindingEvent(finding)
+		}).then(() => void 0),
+		stats: () => opts.preflightSpawn === void 0 ? bus.stats() : {
+			...bus.stats(),
+			preflight: { ...preflightCounts }
+		},
+		isStopped: () => stopped,
+		stopReason: () => reason,
+		submittedResult: () => submitted,
+		settled: () => ledger,
+		questions: () => questions,
+		drainResolved,
+		abortWorker,
+		...peerMail ? { peerMail } : {}
+	};
+}
+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));
+}
+/** Stringify a findings payload for a routed delivery; never throws (a cyclic payload degrades to
+*  its String form rather than killing the settle path). */
+function safeJsonText(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(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/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
+* executor has produced its output. The inner `score` is preserved; only `valid` is gated.
+*/
+function gateOnDeliverable(inner, deliverable) {
+	let gated;
+	const check = async (out, baseScore) => {
+		let delivered;
+		try {
+			delivered = await deliverable.check(out) === true;
+		} catch {
+			delivered = false;
+		}
+		return {
+			valid: delivered,
+			score: baseScore ?? (delivered ? 1 : 0)
+		};
+	};
+	/**
+	* 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) } : {},
+		...inner.progress ? { progress: () => inner.progress?.() } : {},
+		...inner.traceSource ? { traceSource: () => inner.traceSource?.() } : {},
+		...inner.metered ? { metered: () => inner.metered?.() } : {},
+		execute(task, signal) {
+			const r = inner.execute(task, signal);
+			if (isAsyncIterable$1(r)) return (async function* () {
+				try {
+					for await (const ev of r) yield ev;
+				} finally {
+					await settleVerdict();
+				}
+			})();
+			return (async () => {
+				let res;
+				try {
+					res = await r;
+				} catch (error) {
+					await settleVerdict();
+					throw error;
+				}
+				gated = await check(res.out, res.verdict?.score);
+				return {
+					...res,
+					verdict: gated
+				};
+			})();
+		},
+		teardown: (grace) => inner.teardown(grace),
+		resultArtifact() {
+			const art = inner.resultArtifact();
+			return {
+				...art,
+				verdict: gated ?? art.verdict
+			};
+		}
+	});
+}
+/**
+* Transform a Runtime executor's terminal artifact without losing its private
+* profile-materialization attestation or altering its measured spend. This is
+* the composition point for deterministic post-processing and grading; callers
+* must not rebuild an Executor around a model transport merely to change `out`.
+*/
+function mapExecutorResult(inner, map) {
+	let mapped;
+	const settle = async (result, task) => {
+		const transformed = await map(result, task);
+		mapped = {
+			outRef: transformed.outRef,
+			out: transformed.out,
+			...transformed.verdict ? { verdict: transformed.verdict } : {},
+			spent: result.spent
+		};
+		return mapped;
+	};
+	return inheritRuntimeOwnedExecutorAttestation(inner, {
+		runtime: inner.runtime,
+		...inner.budgetExempt !== void 0 ? { budgetExempt: inner.budgetExempt } : {},
+		...inner.deliver ? { deliver: (message) => inner.deliver?.(message) } : {},
+		...inner.progress ? { progress: () => inner.progress?.() } : {},
+		...inner.traceSource ? { traceSource: () => inner.traceSource?.() } : {},
+		...inner.accounting ? { accounting: () => inner.accounting?.() } : {},
+		...inner.metered ? { metered: () => inner.metered?.() } : {},
+		execute(task, signal) {
+			const execution = inner.execute(task, signal);
+			if (isAsyncIterable$1(execution)) return (async function* () {
+				for await (const event of execution) yield event;
+				await settle(inner.resultArtifact(), task);
+			})();
+			return (async () => settle(await execution, task))();
+		},
+		teardown: (grace) => inner.teardown(grace),
+		resultArtifact() {
+			if (!mapped) throw new Error("mapExecutorResult: resultArtifact() read before execute()");
+			return mapped;
+		}
+	});
+}
+function isAsyncIterable$1(v) {
+	return v != null && typeof v[Symbol.asyncIterator] === "function";
+}
+//#endregion
+//#region src/runtime/supervise/otel-spans.ts
+/**
+* Supervisor tree → OTLP spans. OPT-IN, off by default.
+*
+* WHY. A supervised tree is legible today only by parsing this package's own spawn journal, so
+* every other multi-agent shape on the machine (a coding-CLI's subagents, a pi fanout, ad-hoc tool
+* parallelism) needs its own bespoke reader. A span carrying `parent_span_id` IS a tree, and any
+* system can emit one — so emitting spans makes the supervisor readable by the same viewer as
+* everything else, with no per-system reader.
+*
+* WHAT IT IS NOT. This is telemetry, never the record of truth. The spawn journal remains the sole
+* durable ledger for replay/resume and for cost; nothing here is read back, and a run whose export
+* fails is unaffected in every observable way. The two data models are deliberately separate.
+*
+* HOW IT ATTACHES. This is a pure `RuntimeHooks` observer over the lifecycle events `Scope` ALREADY
+* emits — `agent.spawn` (a node opened), `agent.child` (a node settled), `agent.turn` (a driver
+* inference turn was metered). It adds no event, mutates no journal, and changes no result. Because
+* `Scope` re-seeds the same hooks into every nested scope (`makeNestedScopeSeam`), one observer sees
+* the WHOLE recursion at arbitrary depth.
+*
+* SPAN SHAPE. One span per supervised node, opened at spawn and closed at settle, parented to its
+* parent node's span; the run root is the trace. Driver inference rides as an `LLM` child span under
+* the node that metered it. Attributes reuse the vocabulary the rest of the stack already reads
+* (`openinference.span.kind`, `agent.name`, `llm.token_count.*`, `llm.cost_usd`, `tangle.cost.usd`)
+* — see `@tangle-network/agent-eval`'s `src/trace/attribute-vocabulary.ts`, which is the consumer.
+*
+* UNKNOWN IS NEVER ZERO. `Spend.tokensKnown === false` / `usdKnown === false` mark work that
+* HAPPENED with an unreported count. Those spans OMIT the token/cost attribute entirely and set
+* `tangle.supervise.tokens_known` / `tangle.supervise.cost_known` to `false`, so a reader can never
+* mistake an unmeasured turn for a free one.
+*/
+/** OTEL status codes (`UNSET` / `OK` / `ERROR`) — the numeric wire values `OtelSpan.status` carries. */
+const STATUS_UNSET = 0;
+const STATUS_OK = 1;
+const STATUS_ERROR = 2;
+/** Longest string attribute value written from free-form detail, so an oversized turn payload
+*  cannot inflate a span. Identity/label attributes we control are never truncated. */
+const MAX_DETAIL_CHARS = 256;
+/**
+* Build the span recorder for one supervised run, or `undefined` when no exporter resolves — the
+* off-by-default path. A run that passes no `exporter` and no `exportConfig` never reaches this
+* function at all; one that passes an `exportConfig` with no endpoint (and no env endpoint) gets
+* `undefined` here, so "configured but unreachable" also costs nothing.
+*/
+function createSupervisorSpanRecorder(opts) {
+	const exporter = opts.exporter ?? createOtelExporter(opts.exportConfig);
+	if (!exporter) return void 0;
+	const ownsExporter = opts.exporter === void 0;
+	const now = opts.now ?? Date.now;
+	const traceId = normalizeTraceId(opts.traceId, opts.runId);
+	const rootSpanId = generateSpanId();
+	const rootStartMs = now();
+	const base = {
+		"tangle.run.id": opts.runId,
+		"tangle.sessionId": opts.runId,
+		...opts.attributes ?? {}
+	};
+	/** Node id → its open span. Seeded with the run id ⇒ the root span, because a depth-0 spawn's
+	*  `parentId` is the run id itself and every deeper spawn's is a real node id. */
+	const open = /* @__PURE__ */ new Map();
+	const spanIdOf = /* @__PURE__ */ new Map([[opts.runId, rootSpanId]]);
+	let finished = false;
+	/** Every export is best-effort: a throwing exporter must never reach the run. */
+	const emit = (span) => {
+		try {
+			exporter.exportSpan(span);
+		} catch {}
+	};
+	const span = (spanId, parentSpanId, name, startMs, endMs, attrs, status, message) => ({
+		traceId,
+		spanId,
+		...parentSpanId ? { parentSpanId } : {},
+		name,
+		kind: 1,
+		startTimeUnixNano: msToNano(startMs),
+		endTimeUnixNano: msToNano(Math.max(startMs, endMs)),
+		attributes: toOtelAttributes(attrs),
+		status: {
+			code: status,
+			...message ? { message } : {}
+		}
+	});
+	function onSpawn(event) {
+		const p = record(event.payload);
+		const childId = str(p.childId);
+		if (!childId) return;
+		const label = str(p.label) ?? "node";
+		const runtime = str(p.runtime);
+		const isWait = runtime === "wait";
+		const attrs = {
+			...base,
+			"openinference.span.kind": isWait ? "CHAIN" : "AGENT",
+			"agent.name": label,
+			"tangle.supervise.node.id": childId,
+			"tangle.supervise.node.label": label,
+			"tangle.supervise.node.kind": isWait ? "wait" : "agent",
+			"tangle.supervise.tree.root": event.runId
+		};
+		if (event.parentId) attrs["tangle.supervise.node.parent_id"] = event.parentId;
+		if (runtime) attrs["tangle.supervise.node.runtime"] = runtime;
+		if (typeof p.depth === "number") attrs["tangle.supervise.node.depth"] = p.depth;
+		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.ordinal"] = event.stepIndex;
+		if (p.resumed === true) attrs["tangle.supervise.node.resumed"] = true;
+		assignBudget(attrs, p.budget);
+		const spanId = generateSpanId();
+		spanIdOf.set(childId, spanId);
+		open.set(childId, {
+			spanId,
+			parentSpanId: event.parentId && spanIdOf.get(event.parentId) || rootSpanId,
+			name: label,
+			startMs: event.timestamp,
+			attrs
+		});
+	}
+	function onSettled(event) {
+		const p = record(event.payload);
+		const childId = str(p.childId);
+		if (!childId) return;
+		const node = open.get(childId);
+		if (!node) return;
+		open.delete(childId);
+		const status = str(p.status);
+		const down = status === "down";
+		const attrs = {
+			...node.attrs,
+			"tangle.supervise.node.status": status ?? "done"
+		};
+		if (typeof event.stepIndex === "number") attrs["tangle.supervise.node.seq"] = event.stepIndex;
+		if (typeof p.outRef === "string") attrs["tangle.supervise.node.out_ref"] = p.outRef;
+		if (typeof p.valid === "boolean") attrs["tangle.supervise.verdict.valid"] = p.valid;
+		if (typeof p.score === "number") attrs["tangle.supervise.verdict.score"] = p.score;
+		if (down) {
+			attrs["error.type"] = p.infra === true ? "infra" : "child-down";
+			const reason = str(p.reason);
+			if (reason) attrs["error.message"] = truncate(reason);
+			if (typeof p.infra === "boolean") attrs["tangle.supervise.node.infra"] = p.infra;
+		}
+		const wokeBy = str(record(p.wait).settled);
+		if (wokeBy) attrs["tangle.supervise.wait.settled"] = wokeBy;
+		assignSpend(attrs, p.spent);
+		emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, event.timestamp, attrs, down ? STATUS_ERROR : STATUS_OK, down ? str(p.reason) ?? "child down" : void 0));
+	}
+	function onTurn(event) {
+		const p = record(event.payload);
+		const parentId = event.parentId;
+		const parentSpanId = parentId && spanIdOf.get(parentId) || rootSpanId;
+		const attrs = {
+			...base,
+			"openinference.span.kind": "LLM",
+			"inference.observation_kind": "LLM",
+			"tangle.supervise.node.kind": "inference"
+		};
+		if (parentId) attrs["tangle.supervise.node.id"] = parentId;
+		for (const [key, value] of Object.entries(p)) {
+			if (key === "spend") continue;
+			if (key === "driver" && typeof value === "string") {
+				attrs["agent.name"] = value;
+				attrs["inference.agent_name"] = value;
+				continue;
+			}
+			if (key === "model" && typeof value === "string") {
+				attrs["llm.model_name"] = value;
+				continue;
+			}
+			if (Array.isArray(value)) {
+				const scalars = value.filter((v) => typeof v === "string" || typeof v === "number");
+				if (scalars.length > 0) attrs[`tangle.supervise.turn.${key}`] = truncate(scalars.join(","));
+				continue;
+			}
+			if (typeof value === "string") attrs[`tangle.supervise.turn.${key}`] = truncate(value);
+			else if (typeof value === "number" || typeof value === "boolean") attrs[`tangle.supervise.turn.${key}`] = value;
+		}
+		const spend = assignSpend(attrs, p.spend);
+		const endMs = event.timestamp + (spend?.ms ?? 0);
+		emit(span(generateSpanId(), parentSpanId, "gen_ai.client.inference", event.timestamp, endMs, attrs, STATUS_OK));
+	}
+	return {
+		hooks: { onEvent(event) {
+			if (finished) return;
+			try {
+				if (event.phase !== "after") return;
+				if (event.target === "agent.spawn") onSpawn(event);
+				else if (event.target === "agent.child") onSettled(event);
+				else if (event.target === "agent.turn") onTurn(event);
+			} catch {}
+		} },
+		traceId,
+		rootSpanId,
+		workerTrace(spawningNodeId) {
+			return {
+				traceId,
+				parentSpanId: spanIdOf.get(spawningNodeId) ?? rootSpanId
+			};
+		},
+		async finish(outcome) {
+			if (finished) return;
+			finished = true;
+			const endMs = now();
+			try {
+				for (const [nodeId, node] of open) emit(span(node.spanId, node.parentSpanId, node.name, node.startMs, endMs, {
+					...node.attrs,
+					"tangle.supervise.node.status": "unsettled",
+					"tangle.supervise.node.settled": false,
+					"tangle.supervise.node.id": nodeId
+				}, STATUS_UNSET));
+				open.clear();
+				emit(span(rootSpanId, opts.parentSpanId, "supervisor.run", rootStartMs, endMs, rootAttrs(base, opts.agentName ?? "supervisor", outcome), rootStatus(outcome), rootMessage(outcome)));
+				await exporter.flush();
+				if (ownsExporter) await exporter.shutdown();
+			} catch {}
+		}
+	};
+}
+function rootAttrs(base, agentName, outcome) {
+	const attrs = {
+		...base,
+		"openinference.span.kind": "AGENT",
+		"inference.observation_kind": "AGENT",
+		"agent.name": agentName,
+		"inference.agent_name": agentName,
+		"tangle.supervise.node.kind": "root"
+	};
+	const result = outcome?.result;
+	if (result) {
+		attrs["tangle.supervise.result"] = result.kind;
+		if (result.kind === "no-winner") {
+			attrs["tangle.supervise.reason"] = result.reason;
+			attrs["tangle.supervise.down_count"] = result.downCount;
+			if (result.reason === "driver-failed") {
+				attrs["error.type"] = result.error.name;
+				attrs["error.message"] = truncate(result.error.message);
+			}
+		}
+		assignSpend(attrs, result.spentTotal);
+	}
+	if (outcome?.error !== void 0) {
+		attrs["tangle.supervise.result"] = "error";
+		const err = outcome.error;
+		attrs["error.type"] = err instanceof Error ? err.name : typeof err;
+		attrs["error.message"] = truncate(err instanceof Error ? err.message : String(err));
+	}
+	return attrs;
+}
+function rootStatus(outcome) {
+	if (outcome?.error !== void 0) return STATUS_ERROR;
+	if (!outcome?.result) return STATUS_UNSET;
+	return outcome.result.kind === "winner" ? STATUS_OK : STATUS_ERROR;
+}
+function rootMessage(outcome) {
+	if (outcome?.error !== void 0) return truncate(outcome.error instanceof Error ? outcome.error.message : String(outcome.error));
+	const result = outcome?.result;
+	return result && result.kind === "no-winner" ? result.reason : void 0;
+}
+/**
+* Write a `Spend` onto a span, honouring the "a missing measurement is never zero" invariant: a
+* channel marked NOT known contributes no number at all and instead flags itself, so nothing
+* downstream can sum an unmeasured turn as free. Returns the spend it read (for the duration).
+*/
+function assignSpend(attrs, value) {
+	if (!isRecord(value)) return void 0;
+	const spend = value;
+	const tokens = isRecord(spend.tokens) ? spend.tokens : void 0;
+	if (spend.tokensKnown === false) attrs["tangle.supervise.tokens_known"] = false;
+	else if (tokens) {
+		if (typeof tokens.input === "number") attrs["llm.token_count.prompt"] = tokens.input;
+		if (typeof tokens.output === "number") attrs["llm.token_count.completion"] = tokens.output;
+	}
+	if (spend.usdKnown === false) attrs["tangle.supervise.cost_known"] = false;
+	else if (typeof spend.usd === "number" && Number.isFinite(spend.usd)) {
+		attrs["llm.cost_usd"] = spend.usd;
+		attrs["tangle.cost.usd"] = spend.usd;
+	}
+	if (typeof spend.iterations === "number") attrs["tangle.supervise.iterations"] = spend.iterations;
+	if (typeof spend.ms === "number" && spend.ms > 0) attrs["tangle.supervise.duration_ms"] = spend.ms;
+	return spend;
+}
+function assignBudget(attrs, value) {
+	if (!isRecord(value)) return;
+	const budget = value;
+	if (typeof budget.maxTokens === "number") attrs["tangle.supervise.budget.max_tokens"] = budget.maxTokens;
+	if (typeof budget.maxIterations === "number") attrs["tangle.supervise.budget.max_iterations"] = budget.maxIterations;
+	if (typeof budget.maxUsd === "number") attrs["tangle.supervise.budget.max_usd"] = budget.maxUsd;
+}
+/**
+* A trace id must be 32 hex characters. A caller-supplied one is used verbatim when it already is;
+* anything else (and the default) is DERIVED from the run id by content address — deterministic, so
+* a resumed run rejoins the trace its first process opened rather than forking a new one.
+*/
+function normalizeTraceId(traceId, runId) {
+	if (traceId && /^[0-9a-f]{32}$/i.test(traceId)) return traceId.toLowerCase();
+	return contentAddress(traceId ?? runId).slice(7, 39);
+}
+function msToNano(ms) {
+	return (BigInt(Number.isFinite(ms) ? Math.floor(ms) : 0) * 1000000n).toString();
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value) {
+	return isRecord(value) ? value : {};
+}
+function str(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function truncate(value) {
+	return value.length > MAX_DETAIL_CHARS ? `${value.slice(0, MAX_DETAIL_CHARS)}…` : value;
+}
+//#endregion
+//#region src/runtime/supervise/coordination-log.ts
+/**
+* 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 !== "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, 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,
+			...ownerId !== void 0 ? { ownerId } : {},
+			...busRecord
+		};
+		const needsSeparator = await prepareJsonlAppend(this.path);
+		const fh = await fs.open(this.path, "a");
+		try {
+			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+	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 emptyPriorCoordination(ownerId);
+			throw err;
+		}
+		const byId = /* @__PURE__ */ new Map();
+		const findings = [];
+		const continuations = [];
+		const deliveryEvidence = [];
+		const mail = [];
+		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 && ev.down.delivered) byId.set(ev.questionId, {
+					...prior,
+					status: "answered",
+					decision: {
+						kind: "answer",
+						answer: ev.down.instruction,
+						by: "prior-run"
+					}
+				});
+			} else if (ev.type === "instruction") continuations.push(ev.instruction);
+			else if (ev.type === "mail") mail.push(ev.mail);
+		}
+		return {
+			...ownerId !== void 0 ? { ownerId } : {},
+			questions: [...byId.values()],
+			findings,
+			continuations,
+			deliveryEvidence,
+			mail,
+			records
 		};
-	};
+	}
+};
+function emptyPriorCoordination(ownerId) {
 	return {
-		tools,
-		ready,
-		history: () => bus.history(),
-		raiseFinding: (finding) => bus.publish({
-			type: "finding",
-			finding: canonicalFindingEvent(finding)
-		}).then(() => void 0),
-		stats: () => bus.stats(),
-		isStopped: () => stopped,
-		stopReason: () => reason,
-		submittedResult: () => submitted,
-		settled: () => ledger,
-		questions: () => questions,
-		drainResolved,
-		abortWorker,
-		...peerMail ? { peerMail } : {}
+		...ownerId !== void 0 ? { ownerId } : {},
+		questions: [],
+		findings: [],
+		continuations: [],
+		deliveryEvidence: [],
+		mail: [],
+		records: []
 	};
 }
-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 isNoEntError(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
-/** Stringify a findings payload for a routed delivery; never throws (a cyclic payload degrades to
-*  its String form rather than killing the settle path). */
-function safeJsonText(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
+//#endregion
+//#region src/runtime/supervise/run-context.ts
+/**
+*
+* `createInMemoryRunContext` — the one-call bundle of the in-memory stores a
+* `createSupervisor().run(root, task, opts)` needs: a fresh `InMemorySpawnJournal`
+* (the event-sourced spawn log), a fresh `InMemoryResultBlobStore` (the
+* content-addressed `outRef` payload store the driver's `observe`/`finalize` reads
+* settled outputs through), and a fresh `createExecutorRegistry()` (the open
+* `AgentSpec → Executor` resolver).
+*
+* It exists to kill the boilerplate every offline/local supervised run repeats by
+* hand — three constructors threaded into `SupervisorOpts` — and to single-source the
+* ONE wiring invariant that is easy to get wrong: when the root is the recursive
+* `driverAgent` LLM-driver brain AND it may spawn DRIVER children (agents
+* driving agents), the registry MUST be wrapped with `withDriverExecutor` so a
+* `role: 'driver'` child resolves to the nested-scope executor — and that SAME blob
+* store MUST be the one passed to `driverAgent({ blobs })`, or the driver
+* reads from a different store than the scope writes to. Pass `{ withDriver: true }`
+* and reuse the returned `blobs` for both.
+*
+* The spread shape matches `SupervisorOpts` exactly, so the call site reads:
+*   const run = createInMemoryRunContext()
+*   await createSupervisor().run(root, task, { budget, runId, ...run })
+*
+* @experimental
+*/
+/**
+* Build a fresh in-memory run context. Every call returns NEW stores (no shared global
+* state between runs), so two runs never cross-contaminate their journals/blobs.
+*/
+function createInMemoryRunContext(opts = {}) {
+	const base = createExecutorRegistry();
+	return {
+		journal: new InMemorySpawnJournal(),
+		blobs: new InMemoryResultBlobStore(),
+		executors: opts.withDriver ? withDriverExecutor(base) : base
+	};
 }
-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);
+/**
+* Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
+* per append/write) under `dir`, and the context carries `resume: true` so spreading it into
+* `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
+* resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
+* 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, 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.
+*/
+function createFileRunContext(dir, opts = {}) {
+	const base = createExecutorRegistry();
+	return {
+		journal: new FileSpawnJournal(`${dir}/spawn-journal.jsonl`),
+		blobs: new FileResultBlobStore(`${dir}/blobs`),
+		executors: opts.withDriver ? withDriverExecutor(base) : base,
+		resume: true,
+		coordinationLog: new FileCoordinationLog(`${dir}/coordination-log.jsonl`)
+	};
 }
 //#endregion
 //#region src/runtime/anytime.ts
@@ -2680,6 +2710,27 @@ function allOf(...rules) {
 		};
 	};
 }
+/**
+* Evaluate a rule against the run's settled work — the ONE evaluator both supervisor arms call.
+*
+* The router arm calls it before each driver inference turn; the harness arm calls it on each
+* worker settle. Ordering is the contract in both: the hard ceilings (`poolStarved`,
+* `deadlinePassed`, abort, the driver's own stop) are checked first and independently, so a stop
+* rule can only ever ADD a stop — it can never keep a run alive past a budget it has exhausted.
+*
+* Folding the whole roster each call is idempotent by worker id, so it costs O(settled) and never
+* double-counts. `settledAt` carries the instant the ledger recorded a settlement; `now()` is the
+* fallback resolution a per-turn guard has.
+*/
+function progressStop(tracker, rule, ledger, scope, now, stallAfterMs) {
+	for (const w of ledger.settled()) tracker.record({
+		id: w.id,
+		at: w.settledAt ?? now(),
+		...w.score !== void 0 ? { objective: w.score } : {},
+		delivered: w.status === "done" && w.valid === true
+	});
+	return tracker.evaluate(rule, scope, stallAfterMs !== void 0 ? { stallAfterMs } : void 0);
+}
 //#endregion
 //#region src/runtime/supervise/coordination-driver.ts
 /**
@@ -2744,23 +2795,6 @@ function deadlinePassed(scope, now) {
 	const b = scope.budget;
 	return b.deadlineMs > 0 && now() >= b.deadlineMs;
 }
-/**
-* The PROGRESS-derived stop, evaluated strictly AFTER the hard ceilings above.
-*
-* Ordering is the contract, not a detail: `poolStarved` / `deadlinePassed` / abort / the driver's
-* own stop are checked first and independently, so a stop rule can only ever ADD a stop — it can
-* never keep a run alive past a budget it has exhausted. The rule reads the settled-work ledger
-* (via the tracker) plus the live worker feed off the scope; it spends nothing to do so.
-*/
-function progressStop(tracker, rule, coord, scope, now, stallAfterMs) {
-	for (const w of coord.settled()) tracker.record({
-		id: w.id,
-		at: w.settledAt ?? now(),
-		...w.score !== void 0 ? { objective: w.score } : {},
-		delivered: w.status === "done" && w.valid === true
-	});
-	return tracker.evaluate(rule, scope, stallAfterMs !== void 0 ? { stallAfterMs } : void 0);
-}
 function providerAttemptEvidence$1(model) {
 	const attempts = Object.freeze([Object.freeze({ observations: Object.freeze(model === void 0 ? [] : [model]) })]);
 	const models = Object.freeze(model === void 0 ? [] : [model]);
@@ -2814,26 +2848,46 @@ const SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
 /**
 * The worker-cancel ACKNOWLEDGER — the runtime-side half of `run-layout`'s `cancelWorker`
 * contract, run from the coordination driver's turn loop (one cancellation-inbox read per turn,
-* no new process, no poller, no extra lifetime).
+* no new process, no poller, no extra lifetime). Every manager with a `controlDir` mounts one;
+* OWNERSHIP keeps them from colliding: a request naming a node id is owned by the manager whose
+* own id is that node's parent, and a label/profile-name reference is owned by the `'run'`-scoped
+* (root) manager only — so exactly one acknowledger can ever apply one operation.
 *
 * Two-phase, honestly reported: `cancel_requested` is written the moment a live worker's abort is
 * issued (through the per-child abort chain the scope already owns, so siblings are untouched);
 * `cancelled` is written only when that worker's settlement is DELIVERED on the settle path with
 * a terminal `down`, and then the record names every subtree node id proven terminated. A worker
 * that already settled — or that settles `done` despite the abort — records `not_live`; a
-* reference matching nothing this manager knows stays pending (`cancelWorker` reports it
+* reference matching nothing this manager owns stays pending (`cancelWorker` reports it
 * `unknown`). No path reports success for a missing worker.
 *
+* Expiry is run end, not a clock: `finish()` (after the final post-drain pass) writes `not_live`
+* for every owned request never applied and `unknown` for an issued abort whose settle the run
+* ended too soon to observe. A pending request can therefore never outlive its run and abort a
+* future spawn that happens to reuse a label.
+*
 * Idempotency is a lookup, in-process and across processes: an operation with a durable
 * acknowledgement is returned as-is and never re-applied.
 */
 function createCancelAcknowledger(deps) {
 	const tracked = /* @__PURE__ */ new Map();
+	let runTracked;
+	const abortIssuedAt = /* @__PURE__ */ new Map();
 	const iso = () => new Date(deps.now()).toISOString();
 	const write = (record) => {
 		writeWorkerCancellation(deps.dir, record);
 		tracked.set(record.operationId, record);
 	};
+	/** `ref` is exactly one of THIS manager's direct-child node ids (`${ownerId}:s<seq>`). */
+	const directChildId = (ref) => ref.startsWith(`${deps.ownerId}:s`) && /^s\d+$/.test(ref.slice(deps.ownerId.length + 1));
+	/** Whether this acknowledger owns `ref`. A node id deeper in this subtree belongs to the nested
+	*  manager that parents it; anything that is not a node id under this manager is a
+	*  label/profile-name reference, owned by the `'run'`-scoped manager alone. */
+	const owned = (ref) => {
+		if (directChildId(ref)) return true;
+		if (deps.controlScope !== "run") return false;
+		return !ref.startsWith(`${deps.ownerId}:`) && ref !== deps.ownerId;
+	};
 	const deliveredTerminal = (id) => {
 		const row = deps.coord.settled().find((w) => w.id === id);
 		if (row !== void 0) return row.status;
@@ -2852,6 +2906,7 @@ function createCancelAcknowledger(deps) {
 			...request.reason === void 0 ? {} : { reason: request.reason }
 		};
 		if (aborted !== void 0) {
+			abortIssuedAt.set(request.operationId, base.observedAt);
 			write({
 				...base,
 				effect: "cancel_requested",
@@ -2870,6 +2925,17 @@ function createCancelAcknowledger(deps) {
 			terminated: []
 		});
 	};
+	/** The proven-terminated set for one record: the worker plus every subtree id with a terminal
+	*  journal record at/after the abort was issued. Union with what the record already names, so
+	*  the set only ever grows (a late teardown journal adds; nothing removes). */
+	const provenTerminated = (record, workerId) => {
+		const since = abortIssuedAt.get(record.operationId) ?? record.observedAt;
+		return [.../* @__PURE__ */ new Set([
+			...record.terminated,
+			workerId,
+			...terminatedDescendants(deps.dir, workerId, since)
+		])].sort();
+	};
 	const reconcile = (record) => {
 		const workerId = record.workerId;
 		if (workerId === void 0) return;
@@ -2880,7 +2946,7 @@ function createCancelAcknowledger(deps) {
 				...record,
 				effect: "cancelled",
 				observedAt: iso(),
-				terminated: [workerId, ...terminatedDescendants(deps.dir, workerId, record.requestedAt)],
+				terminated: provenTerminated(record, workerId),
 				detail: `worker '${workerId}' reached a terminal down state on the settle path`
 			});
 			return;
@@ -2893,8 +2959,56 @@ function createCancelAcknowledger(deps) {
 			detail: `worker '${workerId}' settled done despite the abort request; nothing was terminated`
 		});
 	};
-	return { pass() {
+	/** Re-scan a `cancelled` record while the manager still turns: a descendant whose teardown
+	*  journals after the lead's settle joins the set on a later pass instead of being lost. Only
+	*  a grown set is re-written; the window needs the in-process abort instant, so a record a
+	*  PRIOR process closed stays as that process proved it. */
+	const regrow = (record) => {
+		const workerId = record.workerId;
+		if (workerId === void 0 || !abortIssuedAt.has(record.operationId)) return;
+		const terminated = provenTerminated(record, workerId);
+		if (terminated.length > record.terminated.length) write({
+			...record,
+			observedAt: iso(),
+			terminated
+		});
+	};
+	/**
+	* The RUN-scoped request: seen once, `cancel_requested` written the moment the run's cascading
+	* abort is issued through the one controller the run already has. The `supervise()` settle path
+	* records what the run then actually did — this manager cannot observe its own tree's terminal
+	* state from inside `act`.
+	*
+	* Applied only at a TURN boundary, never on the final post-drain pass: by then the driver has
+	* finished and drained, so a root abort could only void work that is already delivered. A
+	* request that arrives that late expires in `finish()` instead — it terminated nothing.
+	*/
+	const passRun = () => {
+		if (deps.controlScope !== "run" || deps.abortRun === void 0) return;
+		const request = readRunCancelRequest(deps.dir);
+		if (request === void 0) return;
+		if (runTracked !== void 0) return;
+		const prior = readRunCancellation(deps.dir, request.operationId);
+		if (prior !== void 0) {
+			runTracked = prior;
+			return;
+		}
+		const record = {
+			operationId: request.operationId,
+			effect: "cancel_requested",
+			requestedAt: request.at,
+			observedAt: iso(),
+			...request.reason === void 0 ? {} : { reason: request.reason },
+			detail: "root abort issued to the whole run; termination not yet proven"
+		};
+		writeRunCancellation(deps.dir, record);
+		runTracked = record;
+		deps.abortRun(request.reason ?? "run cancel requested");
+	};
+	const pass = (phase) => {
+		if (phase === "turn") passRun();
 		for (const request of readWorkerCancelRequests(deps.dir)) {
+			if (!owned(request.worker)) continue;
 			let record = tracked.get(request.operationId);
 			if (record === void 0) {
 				record = readWorkerCancellation(deps.dir, request.operationId);
@@ -2905,16 +3019,58 @@ function createCancelAcknowledger(deps) {
 				continue;
 			}
 			if (record.effect === "cancel_requested") reconcile(record);
+			else if (record.effect === "cancelled") regrow(record);
 		}
-	} };
+	};
+	return {
+		pass,
+		finish() {
+			const runRequest = deps.controlScope === "run" && deps.abortRun !== void 0 ? readRunCancelRequest(deps.dir) : void 0;
+			if (runRequest !== void 0 && readRunCancellation(deps.dir, runRequest.operationId) === void 0) writeRunCancellation(deps.dir, {
+				operationId: runRequest.operationId,
+				effect: "not_live",
+				requestedAt: runRequest.at,
+				observedAt: iso(),
+				...runRequest.reason === void 0 ? {} : { reason: runRequest.reason },
+				detail: "run ended before the request was applied"
+			});
+			for (const request of readWorkerCancelRequests(deps.dir)) {
+				if (!owned(request.worker)) continue;
+				const record = tracked.get(request.operationId) ?? readWorkerCancellation(deps.dir, request.operationId);
+				if (record === void 0) {
+					write({
+						operationId: request.operationId,
+						worker: request.worker,
+						effect: "not_live",
+						requestedAt: request.at,
+						observedAt: iso(),
+						...request.reason === void 0 ? {} : { reason: request.reason },
+						detail: "run ended before the request was applied",
+						terminated: []
+					});
+					continue;
+				}
+				if (record.effect === "cancel_requested") write({
+					...record,
+					effect: "unknown",
+					observedAt: iso(),
+					detail: "abort issued; run ended before termination was observed"
+				});
+			}
+		}
+	};
 }
 /**
 * Subtree node ids with a terminal `down`/`cancelled` journal record at or after `sinceIso` —
-* the descendants a cancelled lead's cascading abort took down, read from the durable spawn
-* journal beside the run layout (the nested trees journal their terminal records before the lead
-* itself settles). Ids are hierarchical (`parent:sN`), so `${nodeId}:` prefixes exactly the
-* subtree. Tolerant of a missing or partially-written journal: evidence that cannot be read
-* names fewer nodes, never wrong ones.
+* the abort-issue instant (the acknowledger's own `observedAt` on the `cancel_requested` record,
+* runtime clock), never the client's `requestedAt` — read from the durable spawn journal beside
+* the run layout. The set is proven at acknowledgement time and is approximate about post-abort
+* causation: a descendant that died of its OWN cause after the abort was issued is
+* indistinguishable from the cascade and may be included; one whose teardown journals late joins
+* on a later acknowledger pass; a teardown journal still absent when the run ends is absent from
+* the set. Ids are hierarchical (`parent:sN`), so `${nodeId}:` prefixes exactly the subtree.
+* Tolerant of a missing or partially-written journal: evidence that cannot be read names fewer
+* nodes, never wrong ones.
 */
 function terminatedDescendants(dir, nodeId, sinceIso) {
 	let raw;
@@ -2983,16 +3139,21 @@ function driverAgent(opts) {
 				...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
 				...opts.stallAfterMs !== void 0 ? { stallAfterMs: opts.stallAfterMs } : {},
 				...opts.continuityByProfile ? { continuityByProfile: opts.continuityByProfile } : {},
+				...opts.preflightSpawn ? { preflightSpawn: opts.preflightSpawn } : {},
 				...opts.onEvent ? { onEvent: opts.onEvent } : {},
 				...opts.replaySettlements ? { replaySettlements: true } : {},
 				...opts.priorCoordination?.questions.length ? { priorQuestions: opts.priorCoordination.questions } : {}
 			});
 			await coord.ready();
+			opts.onCoordinationTools?.(coord.tools);
 			const acknowledger = opts.controlDir === void 0 ? void 0 : createCancelAcknowledger({
 				dir: opts.controlDir,
 				coord,
 				scope,
-				now
+				now,
+				ownerId: scope.view.root,
+				controlScope: opts.controlScope ?? "run",
+				...opts.abortRun ? { abortRun: opts.abortRun } : {}
 			});
 			for (const w of scope.resume?.waits ?? []) {
 				const rearmed = scope.wait(w.spec, { label: w.label });
@@ -3162,7 +3323,7 @@ function driverAgent(opts) {
 				maxTurns,
 				hooks: {
 					beforeTurn: (_turn, messages) => {
-						acknowledger?.pass();
+						acknowledger?.pass("turn");
 						const pending = inbox.drain();
 						if (pending.length > 0) messages.push({
 							role: "user",
@@ -3183,7 +3344,8 @@ function driverAgent(opts) {
 				}
 			});
 			await coord.drainResolved();
-			acknowledger?.pass();
+			acknowledger?.pass("final");
+			acknowledger?.finish();
 			const submitted = coord.submittedResult();
 			if (submitted) return submitted.result;
 			return runFinalizer(opts.finalizer ?? bestDelivered, {
@@ -5052,9 +5214,11 @@ async function serveCoordinationMcp(opts) {
 		...opts.replaySettlements ? { replaySettlements: true } : {},
 		...opts.questionPolicy ? { questionPolicy: opts.questionPolicy } : {},
 		...opts.priorQuestions?.length ? { priorQuestions: opts.priorQuestions } : {},
+		...opts.preflightSpawn ? { preflightSpawn: opts.preflightSpawn } : {},
 		...opts.peerMail ? { peerMail: typeof opts.peerMail === "object" && opts.peerMail.limits ? { limits: opts.peerMail.limits } : {} } : {}
 	});
 	await coord.ready();
+	opts.onCoordinationTools?.(coord.tools);
 	const mcp = createMcpServer({
 		extraTools: [...coord.tools, ...opts.nodeTools ?? []],
 		serverName: "coordination"
@@ -5635,6 +5799,29 @@ function assertCoordinationBinding(binding) {
 	if (binding?.allowUnauthenticatedRemote === true) return;
 	throw new ConfigError(`supervisorAgent: coordination.host=${JSON.stringify(host)} is not a loopback address and the coordination MCP has no authentication: any client that can reach the port could call spawn_agent/steer_agent and spend this run's budget. Bind a loopback host ("127.0.0.1", "localhost", "::1"), or set coordination.allowUnauthenticatedRemote: true to accept that exposure explicitly.`);
 }
+function createVerbSlot() {
+	let bound;
+	const verb = (name) => async (args) => {
+		if (bound === void 0) throw new ValidationError(`supervisorAgent: coordination verb "${name}" was called before this manager's coordination tools were bound`);
+		const tool = bound.find((descriptor) => descriptor.name === name);
+		if (tool === void 0) throw new ValidationError(`supervisorAgent: coordination verb "${name}" is not mounted on this manager`);
+		return tool.handler(args);
+	};
+	return {
+		verbs: Object.freeze({
+			spawnAgent: verb("spawn_agent"),
+			awaitEvent: verb("await_event"),
+			steerAgent: verb("steer_agent"),
+			observeAgent: verb("observe_agent"),
+			listQuestions: verb("list_questions"),
+			answerQuestion: verb("answer_question"),
+			runAnalyst: verb("run_analyst")
+		}),
+		bind(tools) {
+			bound = tools;
+		}
+	};
+}
 const ROUTER_TRANSPORT_FIELDS = /* @__PURE__ */ new Set([
 	"routerBaseUrl",
 	"routerKey",
@@ -5682,12 +5869,13 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 	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.peerMail) throw new ValidationError("supervisorAgent: peerMail is only served by a harness-brained supervisor (profile.harness set). A router-brained supervisor serves no coordination MCP listener, so there is no peer-mail post office to mint worker capabilities from.");
 	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) {
 		assertRouterArmResourcePolicy(stableProfile);
 		const brain = testBrain ?? routerBrainFromProfile(stableProfile, stableRouter);
 		const inbox = createInbox();
-		const build = (priorCoordination, nodeTools, onEvent) => driverAgent({
+		const build = (priorCoordination, nodeTools, onEvent, slot) => driverAgent({
 			name,
 			brain,
 			...testBrain === void 0 ? { expectedModel: resolveSupervisorModelId(stableProfile) } : {},
@@ -5707,6 +5895,7 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.watchWorkers ? { watchWorkers: deps.watchWorkers } : {},
 			...deps.stallAfterMs !== void 0 ? { stallAfterMs: deps.stallAfterMs } : {},
 			...deps.continuityByProfile ? { continuityByProfile: deps.continuityByProfile } : {},
+			...deps.preflightSpawn ? { preflightSpawn: deps.preflightSpawn } : {},
 			...deps.stopRule ? { stopRule: deps.stopRule } : {},
 			...deps.onProgressStop ? { onProgressStop: deps.onProgressStop } : {},
 			...deps.maxTurns !== void 0 ? { maxTurns: deps.maxTurns } : {},
@@ -5715,7 +5904,10 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			...deps.replaySettlements ? { replaySettlements: true } : {},
 			...priorCoordination ? { priorCoordination } : {},
 			...deps.finalizer ? { finalizer: deps.finalizer } : {},
+			...slot ? { onCoordinationTools: (tools) => slot.bind(tools) } : {},
 			...deps.controlDir === void 0 ? {} : { controlDir: deps.controlDir },
+			...deps.controlScope === void 0 ? {} : { controlScope: deps.controlScope },
+			...deps.abortRun ? { abortRun: deps.abortRun } : {},
 			inbox
 		});
 		if (!deps.loadPriorCoordination && !resolveTools && !observeNodeEvent) return build(deps.priorCoordination, void 0, deps.onEvent);
@@ -5727,9 +5919,10 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 			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 slot = createVerbSlot();
+				const nodeTools = resolveTools && context ? await bindSupervisorTools(resolveTools, context, scope.signal, slot) : void 0;
 				const onEvent = bindSupervisorNodeObserver(context, observeNodeEvent, deps.onEvent);
-				return build(priorCoordination, nodeTools, onEvent).act(task, scope);
+				return build(priorCoordination, nodeTools, onEvent, slot).act(task, scope);
 			}
 		};
 	}
@@ -5744,9 +5937,24 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 		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 slot = createVerbSlot();
+			const nodeTools = resolveTools && context ? await bindSupervisorTools(resolveTools, context, scope.signal, slot) : void 0;
+			const nodeObserver = bindSupervisorNodeObserver(context, observeNodeEvent, deps.onEvent);
 			const stopController = new AbortController();
+			const tracker = deps.stopRule ? createProgressTracker({ now: Date.now }) : void 0;
+			let progressStopReason;
+			let ledger;
+			const rule = deps.stopRule;
+			const onEvent = tracker && rule ? async (event, record) => {
+				await nodeObserver?.(event, record);
+				if (event.type !== "settled") return;
+				if (ledger === void 0) throw new ValidationError("supervisorAgent: a worker settled before the coordination server was bound");
+				const decision = progressStop(tracker, rule, ledger, scope, Date.now, deps.stallAfterMs);
+				if (!decision.stop || progressStopReason !== void 0) return;
+				progressStopReason = decision.reason;
+				deps.onProgressStop?.(decision.reason);
+				if (!stopController.signal.aborted) stopController.abort(decision.reason);
+			} : nodeObserver;
 			const mcp = await serveCoordinationMcp({
 				scope,
 				blobs: deps.blobs,
@@ -5768,9 +5976,13 @@ function buildSupervisorAgent(profile, deps, testBrain) {
 				...deps.continuityByProfile ? { continuityByProfile: deps.continuityByProfile } : {},
 				...onEvent ? { onEvent } : {},
 				...deps.replaySettlements ? { replaySettlements: true } : {},
+				...deps.preflightSpawn ? { preflightSpawn: deps.preflightSpawn } : {},
+				...deps.peerMail ? { peerMail: deps.peerMail } : {},
 				...priorCoordination?.questions.length ? { priorQuestions: priorCoordination.questions } : {},
-				...nodeTools?.length ? { nodeTools } : {}
+				...nodeTools?.length ? { nodeTools } : {},
+				onCoordinationTools: (tools) => slot.bind(tools)
 			});
+			ledger = mcp;
 			try {
 				const baseTokensLeft = scope.budget.tokensLeft;
 				await runDriverWithRetry({
@@ -5828,12 +6040,13 @@ function supervisorNodeContext(seed, profile, task, scope) {
 		task
 	}, "supervisorAgent trusted node context");
 }
-async function bindSupervisorTools(resolveTools, context, signal) {
+async function bindSupervisorTools(resolveTools, context, signal, slot) {
 	const resolved = await resolveTools(context);
 	if (!Array.isArray(resolved)) throw new ValidationError("supervisorAgent: resolveSupervisorTools must return an array");
 	const invocationContext = Object.freeze({
 		...context,
-		signal
+		signal,
+		verbs: slot.verbs
 	});
 	const names = new Set(coordinationVerbNames);
 	return Object.freeze(resolved.map((rawTool, index) => {
@@ -5876,7 +6089,7 @@ function routerBrainFromProfile(profile, router) {
 		...router.complete !== void 0 ? { complete: router.complete } : {},
 		model: modelId,
 		...settings.retry !== void 0 ? { retry: settings.retry } : {},
-		...settings.maxTokens !== void 0 ? { maxTokens: settings.maxTokens } : {},
+		...enforceTokenLimits(settings.tokenLimits, "router", "supervisorAgent").applied,
 		...settings.stream !== void 0 ? { stream: settings.stream } : {}
 	}, {
 		...settings.temperature !== void 0 ? { temperature: settings.temperature } : {},
@@ -5932,6 +6145,7 @@ function workerFromBackend(backend, deliverable, seams) {
 		if (!parsed.success) throw new ValidationError(`workerFromBackend: invalid AgentProfile: ${parsed.error.message}`);
 		const profile = parsed.data;
 		assertBackendProfileMaterialization(profile, capturedBackend, "workerFromBackend");
+		assertBridgeProfileMaterializes(profile, capturedBackend, "workerFromBackend");
 		const resumeSessionId = bridgeResumeSessionId(capturedBackend, spawnContext, bridgeSessionByWorker);
 		const name = profile.name ?? "worker";
 		const assignmentId = spawnContext?.assignmentId ?? `unscoped:${unscopedNamespace}:${unscopedOrdinal++}`;
@@ -6030,6 +6244,46 @@ function assertBackendProfileMaterialization(profile, backend, context) {
 	assertProfileContract(profile, backendProfileMaterialization(backend), context);
 }
 /**
+* The dimensions cli-bridge lowers through its OWN native controls rather than the workspace plan,
+* per harness. The pre-spawn check must skip exactly these, or it refuses a profile the bridge
+* would have executed. Mirrors `provisionProfileWorkspace` / `provisionPiProfile` in cli-bridge
+* `src/backends/profile-support.ts`.
+*/
+function bridgeMaterializationSkip(harness) {
+	return harness === "pi" ? ["mcp", "extensions"] : ["mcp"];
+}
+/**
+* The two prompt intents, gated here because they are the ONLY profile dimensions cli-bridge
+* refuses independently of whether a harness materializes a workspace at all
+* (`assertProfilePromptIntentsSupported`, cli-bridge `src/backends/profile-support.ts`): a
+* backend either owns a control that reaches the harness's system-prompt position or it does not.
+* Every other dimension's verdict belongs to the workspace plan the executing backend builds, and
+* the run's own materialization receipt already refuses those after the fact.
+*/
+const gatedPromptDimensions = ["systemPrompt", "appendSystemPrompt"];
+/**
+* Refuse a bridge-bound profile whose prompt intent the harness cannot execute, at the SYNCHRONOUS
+* spawn seam — before the reservation commits, the `spawned` event is journaled, or a token is
+* metered. The verdict is a pure function of the profile and the harness, but the bridge only
+* reaches it while assembling the prompt, by which point the child is spawned, metered, and
+* settled `down` to deliver an answer that was available before it started.
+*
+* Applies to the profiles the runtime SPAWNS — a worker and a nested driver child. A root manager
+* profile is the caller's own input and is not a spawn: the bridge answers it on the manager's
+* first turn without a child ever existing.
+*
+* Silent for every other backend: `cli-worktree` runs the full plan check on its own local plan
+* (`runWorktreeHarness`), and no other backend hands the profile to a harness materializer.
+*/
+function assertBridgeProfileMaterializes(profile, backend, context) {
+	if (backend.backend !== "bridge") return;
+	const harness = agentHarness(profile.harness);
+	if (harness === void 0 || !isMaterializerHarness(harness)) return;
+	const unsupported = unsupportedProfileDimensions(profile, harness, gatedPromptDimensions, bridgeMaterializationSkip(harness));
+	if (unsupported.length === 0) return;
+	throw new ValidationError(`${context}: ${harness} cannot materialize the profile: ${renderUnsupported(unsupported)}`);
+}
+/**
 * The ROOT router-brained supervisor's materialization claim. The router arm consumes the
 * identity fields, the resolved system prompt (`prompt.systemPrompt` + `prompt.instructions` +
 * `resources.instructions`), and the resolved model id (`model.default`); the remaining model
@@ -6062,6 +6316,62 @@ const routerSupervisorProfileMaterialization = defineProfileMaterializationContr
 	]
 });
 const coordinationMcpAlias = "agent-runtime-coordination";
+/** How a harness sees a coordination verb once the MCP is mounted under its reserved alias. */
+const coordinationToolPrefix = `${coordinationMcpAlias.replaceAll("-", "_")}_`;
+/**
+* Tools a child REQUIRES that name the coordination MCP but no coordination verb.
+*
+* A profile can only receive a coordination tool this run actually serves, and the served set is
+* closed (`coordinationVerbNames`). A required name inside the reserved namespace that is not one
+* of them can never mount on any harness, for any backend, at any depth — the harness discovers it
+* only when it starts and exits (`pi exit 78: requested tool "…" is unavailable`), after the child
+* is spawned, journaled and metered.
+*/
+function unmountedCoordinationTools(profile) {
+	const served = new Set(coordinationVerbNames.map((verb) => `${coordinationToolPrefix}${verb}`));
+	return Object.entries(profile.tools ?? {}).filter(([name, required]) => required === true && name.startsWith(coordinationToolPrefix)).map(([name]) => name).filter((name) => !served.has(name));
+}
+/**
+* The pre-flight `supervise` installs for a bridge backend. No new knob: the backend already says
+* where the bridge is, and these are the questions only the bridge can answer.
+*
+* Three causes, in cost order — the pure one first, so a deterministic refusal never pays for a
+* round trip:
+*
+* - `unmountable-tool` — pure; see {@link unmountedCoordinationTools}.
+* - `model-route` — `GET /v1/capabilities?model=<wire id>`. The bridge answers exactly this
+*   question and 404s `no backend matches model "…"`. FAIL CLOSED: any answer that is not a route
+*   refuses, including a transport error or an unexpected status, because a pre-flight that skips
+*   itself on an error is the silent admission it exists to remove.
+* - `bridge-full` — `GET /health` → `admission.active >= admission.maxActive`. ADVISORY by
+*   nature (admission can fill or drain a moment later), so only a POSITIVE reading of fullness
+*   refuses: a `/health` that does not answer, or answers without an admission snapshot, is not
+*   evidence that the bridge is full and admits the spawn.
+*/
+function bridgeSpawnPreflight(seam) {
+	return async (profile) => {
+		const unmounted = unmountedCoordinationTools(profile);
+		if (unmounted.length > 0) return {
+			cause: "unmountable-tool",
+			detail: `no coordination verb is named by ${unmounted.map((name) => JSON.stringify(name)).join(", ")}; this run serves ${coordinationVerbNames.join(", ")}`
+		};
+		const wireModel = profileBridgeWireModel(profile);
+		if (wireModel === void 0) return {
+			cause: "model-route",
+			detail: "the child AgentProfile resolves no bridge wire model (harness + provider + model)"
+		};
+		const routeRefusal = await bridgeModelRouteRefusal(seam, wireModel);
+		if (routeRefusal !== void 0) return {
+			cause: "model-route",
+			detail: routeRefusal
+		};
+		const admission = await bridgeAdmissionRead(seam);
+		if (admission && admission.active >= admission.maxActive) return {
+			cause: "bridge-full",
+			detail: `bridge ${seam.bridgeUrl.replace(/\/$/, "")} admission is full: active ${admission.active} of maxActive ${admission.maxActive}`
+		};
+	};
+}
 const defaultAllowedMcpHosts = [];
 Object.freeze(defaultAllowedMcpHosts);
 /** Manager-authored profiles are untrusted until product policy says otherwise. Remote MCP and
@@ -6081,7 +6391,9 @@ function automaticDriverBackendSupported(backend) {
 /** 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) {
+function driveHarnessFromBackend(backend, executionId, now = Date.now, maxTurns) {
+	if (maxTurns !== void 0 && maxTurns < 0) throw new ValidationError("driveHarnessFromBackend: maxTurns must be >= 0 (0 lifts the turn cap; bounds become the conserved pool + deadline + abort)");
+	const turnCap = maxTurns ?? 0;
 	const boundBackend = bindReusableExecutorExecutionId(captureReusableExecutorConfig(backend, "driveHarnessFromBackend"), executionId);
 	const baseFactory = createExecutor(boundBackend);
 	let activeExecutor;
@@ -6090,25 +6402,23 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now) {
 		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 : null
+			profile: canonicalDriverProfile,
+			harness: boundBackend.backend === "sandbox" ? canonicalDriverProfile.harness : null
 		};
+		const turnStop = turnCap > 0 ? new AbortController() : void 0;
+		const effectiveStopSignal = turnStop === void 0 ? stopSignal : stopSignal === void 0 ? turnStop.signal : AbortSignal.any([stopSignal, turnStop.signal]);
 		const executor = baseFactory(spec, {
 			signal: scope.signal,
 			node: scopeOwnerExecutorNodeContext(scope),
-			seams: stopSignal === void 0 ? {} : { [bridgeStopSignalKey]: stopSignal }
+			seams: {
+				...effectiveStopSignal === void 0 ? {} : { [bridgeStopSignalKey]: effectiveStopSignal },
+				[bridgeRuntimeAttachmentsKey]: { [coordinationMcpAlias]: {
+					transport: "http",
+					url: coordinationMcpUrl
+				} }
+			}
 		});
 		activeExecutor = executor;
 		let completed = false;
@@ -6192,25 +6502,21 @@ function driveHarnessFromBackend(backend, executionId, now = Date.now) {
 		try {
 			const declaration = runtimeOwnedExecutorMaterialization(executor);
 			const executionBinding = runtimeOwnedExecutorExecutionBinding(executor);
-			const authoredProfileFromDriverExecution = (profile) => {
-				const { [coordinationMcpAlias]: _runtimeAttachment, ...authoredMcp } = profile.mcp ?? {};
-				const { mcp: _mcp, ...withoutMcp } = profile;
-				return agentProfileSchema.parse(Object.keys(authoredMcp).length > 0 ? {
-					...withoutMcp,
-					mcp: authoredMcp
-				} : withoutMcp);
-			};
 			if (pending === void 0 && (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`);
 			if (pending !== void 0) {
 				if (pending.runtime !== executor.runtime || pending.binding.attemptId !== scopeOwnerExecutorNodeContext(scope).attemptId) throw new ValidationError("driveHarnessFromBackend: pending executor did not bind the kernel-minted attempt");
-				if (canonicalAgentProfileDigest(authoredProfileFromDriverExecution(pending.declaration.effectiveProfile)) !== canonicalAgentProfileDigest(canonicalDriverProfile)) throw new ValidationError("driveHarnessFromBackend: pending executor changed the authored AgentProfile before execution");
+				if (canonicalAgentProfileDigest(pending.declaration.effectiveProfile) !== canonicalAgentProfileDigest(canonicalDriverProfile)) throw new ValidationError("driveHarnessFromBackend: pending executor changed the authored AgentProfile before execution");
 			} else await publishMaterialization(declaration, executionBinding);
 			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);
+				let turns = 0;
+				for await (const event of run) if (event.kind === "iteration") {
+					await meterPending();
+					turns += 1;
+					if (turnStop !== void 0 && turns >= turnCap && !turnStop.signal.aborted) turnStop.abort(`supervise: maxTurns ${turnCap} reached`);
+				} else if (event.kind !== "progress") pendingUsage.push(event);
 				await meterPending();
 				const artifact = executor.resultArtifact();
 				terminalAccountingCaptured = true;
@@ -6436,6 +6742,49 @@ function captureSuperviseOptions(opts) {
 		...otel === void 0 ? {} : { otel }
 	});
 }
+/**
+* Record what a run-scoped cancel actually did, at the ONE place that observes the run's terminal
+* state: the `supervise()` settle path.
+*
+* The root manager writes `cancel_requested` when it issues the abort; only here is the run's own
+* outcome known. A run that ends `aborted` after that request reads `cancelled`; a run that
+* reached any other terminal state despite the request terminated nothing and reads `not_live`,
+* never a success. A request the run ended before applying is expired here too, so a reader can
+* tell run-over from in-progress and a stale request cannot outlive its run.
+*/
+function recordRunCancellationOutcome(runDir, result, now) {
+	if (runDir === void 0) return;
+	const dir = resolve(runDir);
+	const request = readRunCancelRequest(dir);
+	if (request === void 0) return;
+	const record = readRunCancellation(dir, request.operationId);
+	if (record !== void 0 && record.effect !== "cancel_requested") return;
+	const aborted = result.kind === "no-winner" && result.reason === "aborted";
+	const observedAt = new Date(now()).toISOString();
+	const base = {
+		operationId: request.operationId,
+		requestedAt: request.at,
+		observedAt,
+		...request.reason === void 0 ? {} : { reason: request.reason }
+	};
+	if (record === void 0) {
+		writeRunCancellation(dir, {
+			...base,
+			effect: "not_live",
+			detail: "run ended before the request was applied"
+		});
+		return;
+	}
+	writeRunCancellation(dir, aborted ? {
+		...base,
+		effect: "cancelled",
+		detail: "the run reached its terminal aborted state"
+	} : {
+		...base,
+		effect: "not_live",
+		detail: `run settled ${result.kind === "winner" ? "winner" : result.reason} despite the abort request; nothing was terminated`
+	});
+}
 /** A quarter of token and optional dollar capacity per worker; nested managers partition again. */
 /** A per-child budget may not exceed the conserved pool it is reserved from. */
 function assertPerWorkerWithinPool(perWorker, pool) {
@@ -6593,6 +6942,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 		await options.onCoordinationEvent?.(context, coordinationEventId(context, event), record);
 	} : void 0;
 	const managerBackend = options.driverBackend ?? options.backend;
+	const spawnPreflight = options.backend?.backend === "bridge" ? bridgeSpawnPreflight(options.backend) : void 0;
 	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`);
@@ -6621,7 +6971,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 		return managerBackend && automaticDriverBackendSupported(managerBackend) ? driveHarnessFromBackend(managerBackend, externalExecutionId("supervised-manager", {
 			runNamespace,
 			ownerId: context.ownerId
-		}), options.now ?? Date.now) : void 0;
+		}), options.now ?? Date.now, options.maxTurns) : void 0;
 	};
 	const rootDriveHarness = isExternalSupervisor(canonicalProfile) ? driveHarnessForOwner(freezeDetached({
 		runId,
@@ -6712,6 +7062,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 				})) : 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)}`);
+				if (managerBackend) assertBridgeProfileMaterializes(authorized, managerBackend, `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);
@@ -6740,6 +7091,8 @@ function superviseInternal(profile, task, opts, testBrain) {
 					...options.watchWorkers ? { watchWorkers: options.watchWorkers } : {},
 					...options.stallAfterMs !== void 0 ? { stallAfterMs: options.stallAfterMs } : {},
 					...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
+					...spawnPreflight ? { preflightSpawn: spawnPreflight } : {},
+					...options.peerMail ? { peerMail: options.peerMail } : {},
 					...options.stopRule ? { stopRule: options.stopRule } : {},
 					...options.onProgressStop ? { onProgressStop: options.onProgressStop } : {},
 					...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
@@ -6750,7 +7103,11 @@ function superviseInternal(profile, task, opts, testBrain) {
 						onEvent: (_event, record) => log.append(runId, record, ownerId),
 						loadPriorCoordination: () => log.load(runId, ownerId)
 					} : {},
-					...finalizer ? { finalizer } : {}
+					...finalizer ? { finalizer } : {},
+					...options.runDir === void 0 ? {} : {
+						controlDir: resolve(options.runDir),
+						controlScope: "subtree"
+					}
 				}), journal, childExecution.ref);
 			};
 			return makeRecursiveWorker;
@@ -6761,6 +7118,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 	const start = async () => {
 		const priorCoordination = log ? await log.load(runId, rootOwnerId) : void 0;
 		const authorizeRootMessage = authorizeDownFor(canonicalProfile, 1);
+		const runControl = options.rootHandle ?? (options.runDir === void 0 ? void 0 : createRootHandle());
 		const agentDeps = {
 			blobs,
 			makeWorkerAgent: workerFactory,
@@ -6774,6 +7132,8 @@ function superviseInternal(profile, task, opts, testBrain) {
 			...priorCoordination && (priorCoordination.questions.length > 0 || priorCoordination.findings.length > 0 || priorCoordination.continuations.length > 0 || priorCoordination.deliveryEvidence.length > 0) ? { priorCoordination } : {},
 			...finalizer ? { finalizer } : {},
 			...options.coordination ? { coordination: options.coordination } : {},
+			...spawnPreflight ? { preflightSpawn: spawnPreflight } : {},
+			...options.peerMail ? { peerMail: options.peerMail } : {},
 			...options.maxLiveWorkers !== void 0 ? { maxLiveWorkers: options.maxLiveWorkers } : {},
 			...options.router ? { router: options.router } : {},
 			...rootDriveHarness ? { driveHarness: rootDriveHarness } : {},
@@ -6802,7 +7162,10 @@ function superviseInternal(profile, task, opts, testBrain) {
 			...options.compaction ? { compaction: options.compaction } : {},
 			...options.driverRetry ? { driverRetry: options.driverRetry } : {},
 			...options.onDriverAttempt ? { onDriverAttempt: options.onDriverAttempt } : {},
-			...options.runDir === void 0 ? {} : { controlDir: resolve(options.runDir) }
+			...options.runDir === void 0 || runControl === void 0 ? {} : {
+				controlDir: resolve(options.runDir),
+				abortRun: (reason) => runControl.abort(reason)
+			}
 		};
 		const agent = testBrain === void 0 ? supervisorAgent(canonicalProfile, agentDeps) : supervisorAgentWithTestBrain(canonicalProfile, {
 			...agentDeps,
@@ -6816,7 +7179,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 		const recorder = spans;
 		const hooks = recorder ? composeRuntimeHooks(options.hooks, recorder.hooks) : options.hooks;
 		const supervisor = createSupervisor();
-		if (options.rootHandle) supervisor.attach(options.rootHandle);
+		if (runControl !== void 0) supervisor.attach(runControl);
 		const run = supervisor.run(agent, canonicalTask, {
 			budget: options.budget,
 			runId,
@@ -6842,6 +7205,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 		});
 		const settle = async () => {
 			const result = await run;
+			recordRunCancellationOutcome(options.runDir, result, now);
 			const rootProviderModel = ctx.resume === true ? rootProviderModelEvidence([]) : rootProviderModels.length > 0 ? rootProviderModelEvidence(rootProviderModels) : rootDriveHarness === void 0 ? rootProviderModelEvidence([]) : rootProviderModelEvidenceFromExecution(runtimeOwnedDriveHarnessProviderEvidence(rootDriveHarness));
 			return {
 				...result,
@@ -6879,6 +7243,6 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 	return evidence ?? rootProviderModelEvidence([]);
 }
 //#endregion
-export { DELEGATION_TRACE_MAX_BYTES as $, DELEGATION_HISTORY_INPUT_SCHEMA as A, defaultToolDetectors as At, DELEGATE_FEEDBACK_INPUT_SCHEMA as B, createMcpServer as C, plateauLength as Ct, createDelegationStatusHandler as D, createCoordinationTools as Dt, DELEGATION_STATUS_TOOL_NAME as E, canonicalFindingEvent as Et, DELEGATE_UI_AUDIT_INPUT_SCHEMA as F, createSupervisorSpanRecorder as Ft, DELEGATE_INPUT_SCHEMA as G, createDelegateFeedbackHandler as H, DELEGATE_UI_AUDIT_TOOL_NAME as I, gateOnDeliverable as It, validateDelegateArgs as J, DELEGATE_TOOL_NAME as K, createDelegateUiAuditHandler as L, mapExecutorResult as Lt, createDelegationHistoryHandler as M, createFileRunContext as Mt, validateDelegationHistoryArgs as N, createInMemoryRunContext as Nt, validateDelegationStatusArgs as O, normalizeAnalyzeOnSettle as Ot, DELEGATE_UI_AUDIT_DESCRIPTION as P, FileCoordinationLog as Pt, hashIdempotencyInput as Q, validateDelegateUiAuditArgs as R, createInProcessTransport as S, bestSoFar as St, DELEGATION_STATUS_INPUT_SCHEMA as T, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Tt, validateDelegateFeedbackArgs as U, DELEGATE_FEEDBACK_TOOL_NAME as V, DELEGATE_DESCRIPTION as W, delegate as X, defaultDelegateBudget as Y, DelegationTaskQueue as Z, promptHandle as _, noProgressFor as _t, assertCoordinationBinding as a, DelegationPersistenceError as at, classifyDriverFailure as b, anytimeReport as bt, supervisorAgentWithTestBrain as c, InMemoryDelegationStore as ct, delegatesWorkerBriefPrompt as d, driverAgent as dt, DELEGATION_TRACE_MAX_SPANS as et, dumbContinuationFailPrompt as f, finalizeBestDelivered as ft, naiveContinuationPrompt as g, createProgressTracker as gt, kernelPromptRegistry as h, anyOf as ht, workerFromBackend as i, createDelegationTraceCollector as it, DELEGATION_HISTORY_TOOL_NAME as j, watchTrace as jt, DELEGATION_HISTORY_DESCRIPTION as k, createEventBus as kt, analyzesFindingsReportPrompt as l, InMemoryFeedbackStore as lt, formatPromptHandle as m, allWorkersStalled as mt, supervise as n, capDelegationTrace as nt, resolveSupervisorProfile as o, DelegationStateCorruptError as ot, dumbContinuationPassPrompt as p, allOf as pt, createDelegateHandler as q, superviseWithTestBrain as r, composeLoopTraceEmitters as rt, supervisorAgent as s, FileDelegationStore as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, buildDelegationTraceSpans as tt, createPromptRegistry as u, eventToSnapshot as ut, supervisorPolicyPrompt as v, plateau as vt, DELEGATION_STATUS_DESCRIPTION as w, renderAnytimeTable as wt, serveCoordinationMcp as x, areaUnderCurve as xt, DriverAttemptsExhaustedError as y, sampleFromSettled as yt, DELEGATE_FEEDBACK_DESCRIPTION as z };
+export { DELEGATION_TRACE_MAX_BYTES as $, DELEGATION_HISTORY_INPUT_SCHEMA as A, mapExecutorResult as At, DELEGATE_FEEDBACK_INPUT_SCHEMA as B, createMcpServer as C, plateauLength as Ct, createDelegationStatusHandler as D, FileCoordinationLog as Dt, DELEGATION_STATUS_TOOL_NAME as E, createInMemoryRunContext as Et, DELEGATE_UI_AUDIT_INPUT_SCHEMA as F, createEventBus as Ft, DELEGATE_INPUT_SCHEMA as G, createDelegateFeedbackHandler as H, DELEGATE_UI_AUDIT_TOOL_NAME as I, defaultToolDetectors as It, validateDelegateArgs as J, DELEGATE_TOOL_NAME as K, createDelegateUiAuditHandler as L, watchTrace as Lt, createDelegationHistoryHandler as M, canonicalFindingEvent as Mt, validateDelegationHistoryArgs as N, createCoordinationTools as Nt, validateDelegationStatusArgs as O, createSupervisorSpanRecorder as Ot, DELEGATE_UI_AUDIT_DESCRIPTION as P, normalizeAnalyzeOnSettle as Pt, hashIdempotencyInput as Q, validateDelegateUiAuditArgs as R, createInProcessTransport as S, bestSoFar as St, DELEGATION_STATUS_INPUT_SCHEMA as T, createFileRunContext as Tt, validateDelegateFeedbackArgs as U, DELEGATE_FEEDBACK_TOOL_NAME as V, DELEGATE_DESCRIPTION as W, delegate as X, defaultDelegateBudget as Y, DelegationTaskQueue as Z, promptHandle as _, noProgressFor as _t, assertCoordinationBinding as a, DelegationPersistenceError as at, classifyDriverFailure as b, anytimeReport as bt, supervisorAgentWithTestBrain as c, InMemoryDelegationStore as ct, delegatesWorkerBriefPrompt as d, driverAgent as dt, DELEGATION_TRACE_MAX_SPANS as et, dumbContinuationFailPrompt as f, finalizeBestDelivered as ft, naiveContinuationPrompt as g, createProgressTracker as gt, kernelPromptRegistry as h, anyOf as ht, workerFromBackend as i, createDelegationTraceCollector as it, DELEGATION_HISTORY_TOOL_NAME as j, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as jt, DELEGATION_HISTORY_DESCRIPTION as k, gateOnDeliverable as kt, analyzesFindingsReportPrompt as l, InMemoryFeedbackStore as lt, formatPromptHandle as m, allWorkersStalled as mt, supervise as n, capDelegationTrace as nt, resolveSupervisorProfile as o, DelegationStateCorruptError as ot, dumbContinuationPassPrompt as p, allOf as pt, createDelegateHandler as q, superviseWithTestBrain as r, composeLoopTraceEmitters as rt, supervisorAgent as s, FileDelegationStore as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, buildDelegationTraceSpans as tt, createPromptRegistry as u, eventToSnapshot as ut, supervisorPolicyPrompt as v, plateau as vt, DELEGATION_STATUS_DESCRIPTION as w, renderAnytimeTable as wt, serveCoordinationMcp as x, areaUnderCurve as xt, DriverAttemptsExhaustedError as y, sampleFromSettled as yt, DELEGATE_FEEDBACK_DESCRIPTION as z };
 
-//# sourceMappingURL=supervise-hCgG6ROJ.js.map
+//# sourceMappingURL=supervise-BezbzKiJ.js.map