@tangle-network/agent-runtime 0.188.1 → 0.190.0

package/dist/{supervise-BUy1cr2L.js → supervise-yDiZAqlN.js}

@@ -1,20 +1,20 @@
 import { C as runtimeOwnedScopeOwnerRuntime, S as runtimeOwnedPendingExecutorMaterialization, b as runtimeOwnedExecutorMaterialization, d as providerAttemptEvidence, f as recordRuntimeOwnedDriveHarnessProviderEvidence, i as attestRuntimeOwnedScopeOwner, s as inheritRuntimeOwnedExecutorAttestation, v as runtimeOwnedDriveHarnessProviderEvidence, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding } from "./materialization-CekWK6OO.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError, o as NotFoundError, r as BackendTransportError, t as AgentEvalError } from "./errors-CDZ8XsVj.js";
 import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { x as contentAddress } from "./spawn-journal-CxRa-NJ2.js";
-import { v as unmeteredSpend } from "./util-BfoW6RU7.js";
+import { x as contentAddress } from "./spawn-journal-B9eTmVAn.js";
+import { v as unmeteredSpend } from "./util-mCNUeboW.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-Wf2MxXJ9.js";
-import { $ as bridgeModelRouteRefusal, An as controlProfileMaterialization, Fn as promptModelProfileMaterialization, Gt as routerBrain, J as assertValidBudget, K as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Mn as fullProfileMaterialization, Nn as profileMaterializationAxes$1, Pn as promptControlProfileMaterialization, Q as bridgeAdmissionRead, St as createInbox, Un as worktreeCliProfileMaterialization, Vn as unsupportedProfileDimensions, X as spendFromUsageEvents, Z as bindReusableExecutorExecutionId, _ as recordScopeOwnerMaterialization, at as createExecutor, d as driverChild, dn as toOtelAttributes, et as bridgeRuntimeAttachmentsKey, g as meterRuntimeOwnedProviderAttempt, h as meterRuntimeOwnedAccounting, in as createOtelExporter, jn as defineProfileMaterializationContract, kn as assertProfileMaterialization, l as runFinalizer, lt as WORKER_TRACE_PROPAGATION, m as deriveNodeExecutionIdentity, n as createSupervisor, nt as captureReusableExecutorConfig, o as bestDelivered, q as teardownExecutor, sn as generateSpanId, st as snapshotExecutorConfig, t as createRootHandle, tn as buildLoopSpanNodes, tt as bridgeStopSignalKey, u as runTree, v as scopeOwnerExecutorNodeContext, zn as renderUnsupported } from "./supervisor-BSNkaM2a.js";
+import { $ as bridgeModelRouteRefusal, Fn as defineProfileMaterializationContract, Gn as unsupportedProfileDimensions, Gt as routerBrain, In as fullProfileMaterialization, J as assertValidBudget, K as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, Ln as profileMaterializationAxes$1, Nn as assertProfileMaterialization, Pn as controlProfileMaterialization, Q as bridgeAdmissionRead, Rn as promptControlProfileMaterialization, St as createInbox, Un as renderUnsupported, X as spendFromUsageEvents, Z as bindReusableExecutorExecutionId, _ as recordScopeOwnerMaterialization, an as buildLoopSpanNodes, at as createExecutor, cn as createOtelExporter, d as driverChild, dn as generateSpanId, et as bridgeRuntimeAttachmentsKey, g as meterRuntimeOwnedProviderAttempt, h as meterRuntimeOwnedAccounting, hn as toOtelAttributes, l as runFinalizer, lt as WORKER_TRACE_PROPAGATION, m as deriveNodeExecutionIdentity, n as createSupervisor, nt as captureReusableExecutorConfig, o as bestDelivered, q as teardownExecutor, qn as worktreeCliProfileMaterialization, st as snapshotExecutorConfig, t as createRootHandle, tt as bridgeStopSignalKey, u as runTree, v as scopeOwnerExecutorNodeContext, zn as promptModelProfileMaterialization } from "./supervisor-CqJW4qap.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { C as coordinationVerbNames, c as createProgressTracker, d as progressStop, r as driverAgent, v as createFileRunContext, w as createCoordinationTools, y as createInMemoryRunContext } from "./coordination-driver-CtbyZv5d.js";
-import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-Cd_l2XWV.js";
+import { C as coordinationVerbNames, c as createProgressTracker, d as progressStop, r as driverAgent, v as createFileRunContext, w as createCoordinationTools, y as createInMemoryRunContext } from "./coordination-driver-Da1IGdTP.js";
+import { k as writeRunCancellation, o as readRunCancelRequest, s as readRunCancellation } from "./run-layout-B8I_LXN-.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 { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path, { dirname, resolve } from "node:path";
 import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { Readable, Writable } from "node:stream";
 //#region src/runtime/supervise/completion-gate.ts
@@ -84,7 +84,7 @@ function gateOnDeliverable(inner, deliverable) {
 		...inner.metered ? { metered: () => inner.metered?.() } : {},
 		execute(task, signal) {
 			const r = inner.execute(task, signal);
-			if (isAsyncIterable$1(r)) return (async function* () {
+			if (isAsyncIterable$2(r)) return (async function* () {
 				try {
 					for await (const ev of r) yield ev;
 				} finally {
@@ -144,7 +144,7 @@ function mapExecutorResult(inner, map) {
 		...inner.metered ? { metered: () => inner.metered?.() } : {},
 		execute(task, signal) {
 			const execution = inner.execute(task, signal);
-			if (isAsyncIterable$1(execution)) return (async function* () {
+			if (isAsyncIterable$2(execution)) return (async function* () {
 				for await (const event of execution) yield event;
 				await settle(inner.resultArtifact(), task);
 			})();
@@ -157,7 +157,7 @@ function mapExecutorResult(inner, map) {
 		}
 	});
 }
-function isAsyncIterable$1(v) {
+function isAsyncIterable$2(v) {
 	return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
 //#endregion
@@ -440,6 +440,7 @@ function assignSpend(attrs, value) {
 		attrs["tangle.platform.box_minutes_provenance"] = spend.boxMinutesProvenance;
 		attrs["tangle.platform.box_minutes_known"] = spend.boxMinutesKnown === true;
 	}
+	if (spend.tokensProvenance !== void 0) attrs["tangle.supervise.tokens_provenance"] = spend.tokensProvenance;
 	return spend;
 }
 function assignBudget(attrs, value) {
@@ -2440,8 +2441,8 @@ function defaultUnmetContractSteer(context) {
 }
 const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
 const DEFAULT_MAX_ATTEMPTS = 8;
-const DEFAULT_INITIAL_BACKOFF_MS = 2e3;
-const DEFAULT_MAX_BACKOFF_MS = 3e4;
+const DEFAULT_INITIAL_BACKOFF_MS$1 = 2e3;
+const DEFAULT_MAX_BACKOFF_MS$1 = 3e4;
 /**
 * Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal;
 * anything foreign is an accident and is retryable. A `BackendTransportError` is split by status
@@ -2506,7 +2507,7 @@ function describeUnknown(value) {
 		return String(value);
 	}
 }
-async function defaultSleep(ms, signal) {
+async function defaultSleep$1(ms, signal) {
 	if (ms <= 0 || signal.aborted) return;
 	await new Promise((resolve) => {
 		const done = () => {
@@ -2529,13 +2530,13 @@ async function defaultSleep(ms, signal) {
 */
 async function runDriverWithRetry(run) {
 	const now = run.now ?? Date.now;
-	const sleep = run.sleep ?? defaultSleep;
+	const sleep = run.sleep ?? defaultSleep$1;
 	const policy = run.policy ?? {};
 	const retryEnabled = policy.enabled !== false;
 	const maxConsecutive = Math.max(0, policy.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES);
 	const maxAttempts = Math.max(1, policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
-	const initialBackoff = Math.max(0, policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS);
-	const maxBackoff = Math.max(initialBackoff, policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS);
+	const initialBackoff = Math.max(0, policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS$1);
+	const maxBackoff = Math.max(initialBackoff, policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS$1);
 	const maxReprompts = Math.max(0, run.reprompt?.maxReprompts ?? 0);
 	const attempts = [];
 	let consecutiveBarren = 0;
@@ -3266,6 +3267,238 @@ function routerBrainFromProfile(profile, router) {
 	});
 }
 //#endregion
+//#region src/runtime/supervise/worker-retry.ts
+/**
+* WORKER-SPAWN RETRY — the second chance `driverRetry` gives the root, given to a leaf.
+*
+* `driverRetry` guards the root and nothing else. A worker that dies is typed into a `down`
+* settlement, which is the right shape when the worker RAN. It is the wrong shape when the worker
+* never started, and one failure produces exactly that:
+*
+*   bridgeExecutor: bridge stream error: host-executor: acquire timeout after 60000ms
+*   (in_flight=4/4, queued=1)
+*
+* Measured 2026-08-22 on discovery-lab cells oscnp s2/s3: two live cells held 2 leads and up to 8
+* workers on one bridge whose host executor caps live harness children at 4. A worker spawn that
+* queued past the bridge's single 60 s acquire deadline died there, and the run lost that worker
+* permanently even though a slot freed seconds later. The bridge retries nothing.
+*
+* Retrying execution is dangerous by default, so this seam is FAIL-CLOSED on two independent
+* proofs that the attempt did no work:
+*
+*  1. The error carries a PRE-SPAWN signature — a refusal the backend emits before the harness
+*     child or the box exists ({@link isPreSpawnExecutorFailure}). No provider call started.
+*  2. The attempt yielded NO execution event. An attempt that streamed anything may have metered
+*     usage, and a blind re-run would double-spend, so it stays fatal whatever its message says.
+*
+* Either proof missing means no retry. This is deliberately NARROWER than "is this an
+* infrastructure hiccup": `ECONNRESET` is a transient transport failure and is NOT retried here,
+* because it can arrive mid-stream after a metered call.
+*
+* Re-entry re-invokes `execute` on the SAME executor object. Nothing is rebuilt, so the executor's
+* runtime-owned materialization attestation, its bound session id, and its inbox are all the ones
+* the kernel admitted. For the bridge backend a second `execute` is a fresh session stream over the
+* same durable execution id, and a saturation refusal happens before that session's child spawned.
+*
+* @experimental
+*/
+/**
+* The backend refusals that are emitted BEFORE any child process, box, or provider request exists.
+*
+* Each is a queue admission deadline: the executor asked for a slot, waited, and was refused
+* without anything being started. The three names are the pools cli-bridge and the container host
+* admit through — the host executor, one scoped per-run host executor, and the container pool.
+*
+* The pattern is anchored to the whole phrase, including the `after <n>ms` deadline, so a message
+* that merely mentions a queue does not qualify.
+*/
+const PRE_SPAWN_SIGNATURES = Object.freeze([/\b(?:host-executor|scoped-host-executor|container-pool): acquire timeout after \d+ms\b/u]);
+const DEFAULT_MAX_TOTAL_MS = 9e5;
+const DEFAULT_INITIAL_BACKOFF_MS = 5e3;
+const DEFAULT_MAX_BACKOFF_MS = 6e4;
+/**
+* True when `error` is a backend refusal issued before anything ran.
+*
+* This answers "did this fail BEFORE any provider call", which is a strictly narrower question
+* than "is this an infrastructure hiccup". The broader question admits `ECONNRESET` and a bare
+* `fetch failed`, both of which can arrive after a metered call, and answering the broad question
+* where the narrow one is required is what makes a retry double-spend.
+*/
+function isPreSpawnExecutorFailure(error, additionalSignatures = []) {
+	const message = error instanceof Error ? error.message : String(error);
+	for (const signature of PRE_SPAWN_SIGNATURES) if (signature.test(message)) return true;
+	for (const signature of additionalSignatures) if (signature.test(message)) return true;
+	return false;
+}
+/** Read the policy, refusing a number a run cannot act on rather than silently clamping it. */
+function resolveWorkerSpawnRetry(policy) {
+	if (policy === void 0 || policy.enabled === false) return void 0;
+	const maxTotalMs = policy.maxTotalMs ?? DEFAULT_MAX_TOTAL_MS;
+	const initialBackoffMs = policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS;
+	const maxBackoffMs = policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+	for (const [name, value] of [
+		["maxTotalMs", maxTotalMs],
+		["initialBackoffMs", initialBackoffMs],
+		["maxBackoffMs", maxBackoffMs]
+	]) if (!Number.isFinite(value) || value < 0) throw new ValidationError(`workerRetry.${name} must be a nonnegative finite number of milliseconds`);
+	const signatures = policy.additionalPreSpawnSignatures ?? [];
+	for (const signature of signatures) if (!(signature instanceof RegExp)) throw new ValidationError("workerRetry.additionalPreSpawnSignatures must contain RegExp values");
+	return Object.freeze({
+		maxTotalMs,
+		initialBackoffMs,
+		maxBackoffMs: Math.max(initialBackoffMs, maxBackoffMs),
+		signatures: Object.freeze([...signatures])
+	});
+}
+/**
+* Wrap a worker seam so a leaf whose spawn is refused before it runs is re-entered instead of
+* settling dead.
+*
+* The wrapper composes the agent's `executorFactory`, which is where a leaf executor is built with
+* the real child signal and node context, and it never replaces the executor object the factory
+* returned: the retry lives in one `execute` wrapper that carries the inner executor's attestation
+* forward and delegates every other surface to it.
+*/
+function withWorkerSpawnRetry(make, policy, hooks = {}) {
+	const resolved = resolveWorkerSpawnRetry(policy);
+	if (resolved === void 0) return make;
+	return (profile, spawnContext) => {
+		const agent = make(profile, spawnContext);
+		const spec = agent.executorSpec;
+		if (spec === void 0) return agent;
+		const seamHooks = {
+			...hooks,
+			...typeof profile.name === "string" ? { worker: profile.name } : {}
+		};
+		if (spec.executorFactory !== void 0) {
+			const innerFactory = spec.executorFactory;
+			const executorFactory = (builtSpec, ctx) => retryPreSpawnRefusals(innerFactory(builtSpec, ctx), resolved, seamHooks);
+			return {
+				...agent,
+				executorSpec: {
+					...spec,
+					executorFactory
+				}
+			};
+		}
+		if (spec.executor !== void 0) {
+			const executor = retryPreSpawnRefusals(spec.executor, resolved, seamHooks);
+			return {
+				...agent,
+				executorSpec: {
+					...spec,
+					executor
+				}
+			};
+		}
+		return agent;
+	};
+}
+/**
+* Re-enter `execute` on one executor while a pre-spawn refusal keeps proving nothing ran.
+*
+* Exported so an owner of `makeLeafAgent` — which builds its own executors — gets the same seam
+* without reimplementing the two proofs.
+*/
+function retryPreSpawnRefusals(inner, policy, hooks = {}) {
+	const now = hooks.now ?? Date.now;
+	const sleep = hooks.sleep ?? defaultSleep;
+	/** The wait before the next attempt, or `null` when this failure stays fatal. */
+	const nextWait = (error, attempt, yielded, startedAt, signal) => {
+		if (yielded) return null;
+		if (signal?.aborted) return null;
+		if (!isPreSpawnExecutorFailure(error, policy.signatures)) return null;
+		const backoff = Math.min(policy.maxBackoffMs, policy.initialBackoffMs * 2 ** (attempt - 1));
+		if (now() - startedAt + backoff >= policy.maxTotalMs) return null;
+		return backoff;
+	};
+	const report = (error, attempt, waitMs) => {
+		hooks.onRetry?.({
+			attempt,
+			waitMs,
+			...hooks.worker === void 0 ? {} : { worker: hooks.worker },
+			error: error instanceof Error ? error.message : String(error)
+		});
+	};
+	const wrapped = {
+		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.metered ? { metered: () => inner.metered?.() } : {},
+		...inner.interactive === void 0 ? {} : { interactive: () => interactiveOf(inner) },
+		execute(task, signal) {
+			const first = inner.execute(task, signal);
+			const restart = () => inner.execute(task, signal);
+			return isAsyncIterable$1(first) ? retryStream(first, restart, signal) : retryOneShot(first, restart, signal);
+		},
+		teardown: (grace) => inner.teardown(grace),
+		resultArtifact: () => inner.resultArtifact()
+	};
+	async function* retryStream(first, restart, signal) {
+		const startedAt = now();
+		let execution = first;
+		for (let attempt = 1;; attempt += 1) {
+			let yielded = false;
+			try {
+				for await (const event of execution) {
+					yielded = true;
+					yield event;
+				}
+				return;
+			} catch (error) {
+				const waitMs = nextWait(error, attempt, yielded, startedAt, signal);
+				if (waitMs === null) throw error;
+				report(error, attempt, waitMs);
+				await sleep(waitMs, signal);
+				const next = restart();
+				if (!isAsyncIterable$1(next)) throw new ValidationError("retryPreSpawnRefusals: executor changed execution shape between attempts");
+				execution = next;
+			}
+		}
+	}
+	async function retryOneShot(first, restart, signal) {
+		const startedAt = now();
+		let execution = first;
+		for (let attempt = 1;; attempt += 1) try {
+			return await execution;
+		} catch (error) {
+			const waitMs = nextWait(error, attempt, false, startedAt, signal);
+			if (waitMs === null) throw error;
+			report(error, attempt, waitMs);
+			await sleep(waitMs, signal);
+			const next = restart();
+			if (isAsyncIterable$1(next)) throw new ValidationError("retryPreSpawnRefusals: executor changed execution shape between attempts");
+			execution = next;
+		}
+	}
+	return inheritRuntimeOwnedExecutorAttestation(inner, wrapped);
+}
+/** Forward the inner executor's interactive contract exactly. The method is present only when the
+*  inner executor implements it, so the reachable call always has one to delegate to. */
+function interactiveOf(inner) {
+	if (inner.interactive === void 0) throw new ValidationError("retryPreSpawnRefusals: inner executor exposes no interactive session");
+	return inner.interactive();
+}
+function isAsyncIterable$1(value) {
+	return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+}
+/** The wait stays REF'd: a worker waiting out a saturated executor is live work, and an unref'd
+*  timer lets the process exit mid-backoff when nothing else is pending. */
+function defaultSleep(ms, signal) {
+	if (ms <= 0 || signal?.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		const done = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		signal?.addEventListener("abort", done, { once: true });
+	});
+}
+//#endregion
 //#region src/runtime/supervise/supervise.ts
 /**
 * `supervise` — the one-call "just invoke the supervisor". Builds + runs a supervisor from its
@@ -3321,16 +3554,22 @@ function workerFromBackend(backend, deliverable, seams) {
 			...executionScope === void 0 ? {} : { scope: executionScope }
 		}));
 		const boundSessionId = boundBackend.backend === "bridge" ? boundBackend.sessionId : void 0;
+		const peerMailAttachment = peerMailRuntimeAttachment(profile, capturedBackend, spawnContext);
 		const baseFactory = createExecutor(boundBackend);
 		const executorFactory = (spec, ctx) => {
 			if (boundSessionId !== void 0 && ctx.node?.nodeId !== void 0) bridgeSessionByWorker.set(ctx.node.nodeId, boundSessionId);
 			const extraSeams = seams?.();
-			const built = baseFactory(spec, extraSeams === void 0 ? ctx : {
+			const seamsForChild = extraSeams === void 0 && peerMailAttachment === void 0 ? ctx.seams : {
+				...extraSeams,
+				...ctx.seams,
+				...peerMailAttachment === void 0 ? {} : { [bridgeRuntimeAttachmentsKey]: {
+					...readCallerRuntimeAttachments(ctx.seams),
+					...peerMailAttachment
+				} }
+			};
+			const built = baseFactory(spec, seamsForChild === ctx.seams ? ctx : {
 				...ctx,
-				seams: {
-					...extraSeams,
-					...ctx.seams
-				}
+				seams: seamsForChild
 			});
 			return deliverable ? gateOnDeliverable(built, deliverable) : built;
 		};
@@ -3346,6 +3585,63 @@ function workerFromBackend(backend, deliverable, seams) {
 		};
 	};
 }
+/**
+* The reserved MCP alias one worker's PEER MAIL capability endpoint mounts under.
+*
+* Distinct from the driver's coordination alias on purpose: the two servers carry different
+* authority. Coordination mounts spawn_worker / steer_agent / stop; mail mounts send_mail and
+* read_mail and nothing else, on a per-worker secret path bound to that worker's identity.
+*/
+const peerMailMcpAlias = "agent-runtime-peer-mail";
+/**
+* The Runtime-owned MCP attachment that carries this spawn's peer-mail endpoint into the worker,
+* or `undefined` when this backend runs no MCP client at all.
+*
+* The endpoint rides the SAME out-of-band channel the driver's coordination MCP rides
+* (`runtime_attachments` on the bridge wire), for the same reason: the capability path carries
+* fresh random bytes per process, so writing it into `AgentProfile.mcp` would move the canonical
+* profile digest a durable session is bound to, and a keyed re-spawn would then fail its identity
+* check against the journal. Nothing in the authored profile changes, and this runs inside the
+* leaf factory — after `authorizeSpawn` has already decided the profile — so the authorization
+* chain is unchanged.
+*
+* Three backend classes, three honest answers:
+*
+*  - `bridge` MOUNTS it. cli-bridge advertises `capabilities.runtimeAttachments.mcp` and mounts
+*    the named servers for the run without binding them into the session profile.
+*  - `router`, `router-tools` and `provider` mount NOTHING. Those workers are in-process tool
+*    loops with no MCP client; their tool surface is the caller's own array, and
+*    `WorkerSpawnContext.peerMailUrl` is the deliverable a caller uses directly.
+*  - Every other backend REFUSES the spawn. A sandbox box or a local CLI harness receives tools
+*    only through its materialized `AgentProfile`, and the runtime has no channel that reaches it
+*    out of band, so minting a capability it can never call would ledger a channel that does not
+*    exist. This is the same rule `bridgeResumeSessionId` applies to `continuity: 'resume'`.
+*/
+function peerMailRuntimeAttachment(profile, backend, spawnContext) {
+	const url = spawnContext?.peerMailUrl;
+	if (url === void 0) return void 0;
+	switch (backend.backend) {
+		case "router":
+		case "router-tools":
+		case "provider": return;
+		case "bridge": break;
+		default: throw new ValidationError(`workerFromBackend: the '${backend.backend}' backend seam cannot mount a peer-mail endpoint — it materializes tools only through the AgentProfile, and writing a per-process capability URL there would move the canonical profile digest. Run peer-mail workers on the 'bridge' backend, mount the endpoint yourself from WorkerSpawnContext.peerMailUrl through makeLeafAgent or makeWorkerAgent, or drop peerMail for this run`);
+	}
+	if (profile.mcp?.[peerMailMcpAlias] !== void 0) throw new ValidationError(`workerFromBackend: profile MCP alias ${JSON.stringify(peerMailMcpAlias)} is reserved`);
+	return Object.freeze({ [peerMailMcpAlias]: Object.freeze({
+		transport: "http",
+		url
+	}) });
+}
+/**
+* Runtime attachments a caller already put on the child's `ExecutorContext`, so mounting peer mail
+* ADDS one server rather than replacing the map. An absent or malformed value contributes nothing;
+* the executor that reads the seam owns its validation and refuses a malformed map there.
+*/
+function readCallerRuntimeAttachments(seams) {
+	const existing = seams[bridgeRuntimeAttachmentsKey];
+	return existing !== null && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+}
 function externalExecutionId(kind, identity) {
 	return `${kind}-${canonicalCandidateDigest({
 		kind,
@@ -3854,7 +4150,9 @@ const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"stopRule",
 	"watchWorkers",
 	"repromptOnUnmet",
-	"onUnmetContract"
+	"onUnmetContract",
+	"workerRetry",
+	"onWorkerRetry"
 ]);
 /**
 * Refuse a top-level option key `supervise()` reads nowhere, naming it.
@@ -3877,13 +4175,47 @@ function captureDeliverable(deliverable, context) {
 		check: deliverable.check
 	});
 }
+Object.freeze([...[
+	"authorizeMessage",
+	"authorizeSpawn",
+	"driveHarness",
+	"executeExtraTool",
+	"finalizer",
+	"isDriverProfile",
+	"makeLeafAgent",
+	"makeWorkerAgent",
+	"now",
+	"onCoordinationEvent",
+	"onDriverAttempt",
+	"onProgressStop",
+	"onUnmetContract",
+	"onWorkerRetry",
+	"resolveDeliverable",
+	"resolveDriveHarness",
+	"resolveSpawnProfile",
+	"resolveSupervisorTools",
+	"stopRule"
+]]);
+/**
+* Refuse a callback that reached the decision-data remainder, naming the option.
+*
+* The type test above cannot see a callback nested inside an object-valued option, and
+* `detachedSnapshot` would report only that its input is not structured-cloneable. This says which
+* key carries the callback and what to do about it, so the next occurrence is a five-second fix
+* instead of a bisect over every option a caller passed.
+*/
+function assertNoUncapturedExecutableOption(decisionData) {
+	const carried = Object.entries(decisionData).filter(([, value]) => typeof value === "function").map(([key]) => key);
+	if (carried.length > 0) throw new ValidationError(`supervise: option ${carried.sort().join(", ")} carries a callback that the option capture does not forward, so the run would fail on a structured-clone refusal that names the snapshot instead of the option; lift the key out of the decision data in captureSuperviseOptions and add it to superviseExecutableOptionKeys`);
+}
 /** Capture the public one-call configuration before any asynchronous work starts. Decision data is
 * detached and frozen; executable ports are copied as the exact references selected at intake.
 * Service internals intentionally remain live, while replacing a callback/service on the caller's
 * mutable options object can no longer change an in-flight run. */
 function captureSuperviseOptions(opts) {
 	assertSuperviseOptionKeys(opts, "supervise");
-	const { backend, driverBackend, deliverable, resolveDeliverable, router, compaction, watchWorkers, analysts, makeWorkerAgent, makeLeafAgent, resolveSpawnProfile, blobs, journal, probes, registry, hooks, otel, authorizeSpawn, authorizeMessage, isDriverProfile, driveHarness, resolveDriveHarness, resolveSupervisorTools, onCoordinationEvent, executeExtraTool, stopRule, onProgressStop, onDriverAttempt, finalizer, now, signal, rootHandle, ...decisionData } = opts;
+	const { backend, driverBackend, deliverable, resolveDeliverable, router, compaction, watchWorkers, analysts, makeWorkerAgent, makeLeafAgent, resolveSpawnProfile, blobs, journal, probes, registry, hooks, otel, authorizeSpawn, authorizeMessage, isDriverProfile, driveHarness, resolveDriveHarness, resolveSupervisorTools, onCoordinationEvent, executeExtraTool, stopRule, onProgressStop, onDriverAttempt, onUnmetContract, workerRetry, onWorkerRetry, finalizer, now, signal, rootHandle, ...decisionData } = opts;
+	assertNoUncapturedExecutableOption(decisionData);
 	const capturedData = detachedSnapshot(decisionData, "supervise options");
 	const capturedBackend = backend === void 0 ? void 0 : snapshotExecutorConfig(backend);
 	const capturedDriverBackend = driverBackend === void 0 ? void 0 : snapshotExecutorConfig(driverBackend);
@@ -3908,6 +4240,15 @@ function captureSuperviseOptions(opts) {
 		...detachedSnapshot({ maxFindingsPerWorker: watchWorkers.maxFindingsPerWorker }, "supervise worker-watch configuration"),
 		...watchWorkers.detectors === void 0 ? {} : { detectors: Object.freeze([...watchWorkers.detectors]) }
 	});
+	const capturedWorkerRetry = workerRetry === void 0 ? void 0 : Object.freeze({
+		...detachedSnapshot({
+			...workerRetry.enabled === void 0 ? {} : { enabled: workerRetry.enabled },
+			...workerRetry.maxTotalMs === void 0 ? {} : { maxTotalMs: workerRetry.maxTotalMs },
+			...workerRetry.initialBackoffMs === void 0 ? {} : { initialBackoffMs: workerRetry.initialBackoffMs },
+			...workerRetry.maxBackoffMs === void 0 ? {} : { maxBackoffMs: workerRetry.maxBackoffMs }
+		}, "supervise worker-retry configuration"),
+		...workerRetry.additionalPreSpawnSignatures === void 0 ? {} : { additionalPreSpawnSignatures: Object.freeze([...workerRetry.additionalPreSpawnSignatures]) }
+	});
 	const capturedAnalysts = analysts === void 0 || typeof analysts === "string" ? analysts : Object.freeze({
 		kinds: detachedSnapshot(analysts.kinds, "supervise analyst kinds"),
 		run: analysts.run
@@ -3939,6 +4280,9 @@ function captureSuperviseOptions(opts) {
 		...stopRule === void 0 ? {} : { stopRule },
 		...onProgressStop === void 0 ? {} : { onProgressStop },
 		...onDriverAttempt === void 0 ? {} : { onDriverAttempt },
+		...onUnmetContract === void 0 ? {} : { onUnmetContract },
+		...capturedWorkerRetry === void 0 ? {} : { workerRetry: capturedWorkerRetry },
+		...onWorkerRetry === void 0 ? {} : { onWorkerRetry },
 		...finalizer === void 0 ? {} : { finalizer },
 		...now === void 0 ? {} : { now },
 		...signal === void 0 ? {} : { signal },
@@ -4111,6 +4455,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 	const canonicalTask = freezeDetached(task);
 	if (options.makeWorkerAgent && options.authorizeSpawn) throw new ValidationError("supervise: authorizeSpawn cannot be combined with caller-owned makeWorkerAgent; use makeLeafAgent to override leaf execution inside the authorized path, or use backend-derived workers");
 	if (options.makeWorkerAgent && options.makeLeafAgent) throw new ValidationError("supervise: makeWorkerAgent replaces the worker path and makeLeafAgent overrides a leaf inside it; pass one");
+	if (options.makeWorkerAgent && (options.workerRetry || options.onWorkerRetry)) throw new ValidationError("supervise: workerRetry applies only to backend-derived workers; compose withWorkerSpawnRetry onto a caller-owned makeWorkerAgent explicitly");
 	if (options.makeWorkerAgent && options.resolveDeliverable) throw new ValidationError("supervise: resolveDeliverable applies only to backend-derived workers; wrap a caller-owned makeWorkerAgent with its completion checks explicitly");
 	const authorizeDownFor = (parent, depth) => {
 		if (!options.authorizeSpawn && !options.authorizeMessage) return void 0;
@@ -4197,7 +4542,8 @@ function superviseInternal(profile, task, opts, testBrain) {
 	let makeWorkerAgent = options.makeWorkerAgent;
 	if (!makeWorkerAgent) {
 		if (!options.backend && !options.makeLeafAgent) throw new ValidationError("supervise: provide opts.backend (where workers run), opts.makeLeafAgent, or opts.makeWorkerAgent");
-		const makeLeaf = options.makeLeafAgent ?? workerFromBackend(options.backend, deliverable);
+		const withRetry = (make) => withWorkerSpawnRetry(make, options.workerRetry, { ...options.onWorkerRetry ? { onRetry: options.onWorkerRetry } : {} });
+		const makeLeaf = withRetry(options.makeLeafAgent ?? workerFromBackend(options.backend, deliverable));
 		const securityPolicy = options.profileSecurity ?? DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY;
 		const makeRecursiveWorkerFor = (parent, parentIdentity, depth, parentOwnerId) => {
 			const makeRecursiveWorker = (authoredProfile, spawnContext) => {
@@ -4254,7 +4600,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 					const selectedDeliverable = options.resolveDeliverable?.(postAuthorizationContext);
 					const leafDeliverable = selectedDeliverable === void 0 ? deliverable : captureDeliverable(selectedDeliverable, `supervise deliverable for ${JSON.stringify(spawnContext.label)}`);
 					if (leafDeliverable !== deliverable && !options.backend) throw new ValidationError("supervise: resolveDeliverable selected a per-spawn deliverable but there is no backend to derive that leaf from; makeLeafAgent owns its own completion check");
-					return (leafDeliverable === deliverable ? makeLeaf : workerFromBackend(options.backend, leafDeliverable))(authorized, Object.freeze({
+					return (leafDeliverable === deliverable ? makeLeaf : withRetry(workerFromBackend(options.backend, leafDeliverable)))(authorized, Object.freeze({
 						...authorizedContext,
 						assignmentId: workerAssignmentNamespace(runNamespace, parentOwnerId, spawnContext.assignmentId)
 					}));
@@ -4459,6 +4805,6 @@ function rootProviderModelEvidenceFromExecution(evidence) {
 	return evidence ?? rootProviderModelEvidence([]);
 }
 //#endregion
-export { DelegationTaskQueue as $, DELEGATION_HISTORY_DESCRIPTION as A, validateDelegateUiAuditArgs as B, createInProcessTransport as C, DELEGATION_STATUS_TOOL_NAME as D, DELEGATION_STATUS_INPUT_SCHEMA as E, delegationProfiles as F, validateDelegateFeedbackArgs as G, DELEGATE_FEEDBACK_INPUT_SCHEMA as H, DELEGATE_UI_AUDIT_DESCRIPTION as I, DELEGATE_TOOL_NAME as J, DELEGATE_DESCRIPTION as K, DELEGATE_UI_AUDIT_INPUT_SCHEMA as L, DELEGATION_HISTORY_TOOL_NAME as M, createDelegationHistoryHandler as N, createDelegationStatusHandler as O, validateDelegationHistoryArgs as P, delegate as Q, DELEGATE_UI_AUDIT_TOOL_NAME as R, serveCoordinationMcp as S, DELEGATION_STATUS_DESCRIPTION as T, DELEGATE_FEEDBACK_TOOL_NAME as U, DELEGATE_FEEDBACK_DESCRIPTION as V, createDelegateFeedbackHandler as W, validateDelegateArgs as X, createDelegateHandler as Y, defaultDelegateBudget as Z, promptHandle as _, assertCoordinationBinding as a, composeLoopTraceEmitters as at, classifyDriverFailure as b, supervisorAgentWithTestBrain as c, DelegationStateCorruptError as ct, delegatesWorkerBriefPrompt as d, InMemoryFeedbackStore as dt, hashIdempotencyInput as et, dumbContinuationFailPrompt as f, eventToSnapshot as ft, naiveContinuationPrompt as g, kernelPromptRegistry as h, mapExecutorResult as ht, workerFromBackend as i, capDelegationTrace as it, DELEGATION_HISTORY_INPUT_SCHEMA as j, validateDelegationStatusArgs as k, analyzesFindingsReportPrompt as l, FileDelegationStore as lt, formatPromptHandle as m, gateOnDeliverable as mt, supervise as n, DELEGATION_TRACE_MAX_SPANS as nt, resolveSupervisorProfile as o, createDelegationTraceCollector as ot, dumbContinuationPassPrompt as p, createSupervisorSpanRecorder as pt, DELEGATE_INPUT_SCHEMA as q, superviseWithTestBrain as r, buildDelegationTraceSpans as rt, supervisorAgent as s, DelegationPersistenceError as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, DELEGATION_TRACE_MAX_BYTES as tt, createPromptRegistry as u, InMemoryDelegationStore as ut, supervisorPolicyPrompt as v, createMcpServer as w, defaultUnmetContractSteer as x, DriverAttemptsExhaustedError as y, createDelegateUiAuditHandler as z };
+export { createDelegateHandler as $, DELEGATION_STATUS_INPUT_SCHEMA as A, DELEGATE_UI_AUDIT_DESCRIPTION as B, DriverAttemptsExhaustedError as C, createInProcessTransport as D, serveCoordinationMcp as E, DELEGATION_HISTORY_INPUT_SCHEMA as F, DELEGATE_FEEDBACK_DESCRIPTION as G, DELEGATE_UI_AUDIT_TOOL_NAME as H, DELEGATION_HISTORY_TOOL_NAME as I, createDelegateFeedbackHandler as J, DELEGATE_FEEDBACK_INPUT_SCHEMA as K, createDelegationHistoryHandler as L, createDelegationStatusHandler as M, validateDelegationStatusArgs as N, createMcpServer as O, DELEGATION_HISTORY_DESCRIPTION as P, DELEGATE_TOOL_NAME as Q, validateDelegationHistoryArgs as R, supervisorPolicyPrompt as S, defaultUnmetContractSteer as T, createDelegateUiAuditHandler as U, DELEGATE_UI_AUDIT_INPUT_SCHEMA as V, validateDelegateUiAuditArgs as W, DELEGATE_DESCRIPTION as X, validateDelegateFeedbackArgs as Y, DELEGATE_INPUT_SCHEMA as Z, dumbContinuationPassPrompt as _, createSupervisorSpanRecorder as _t, isPreSpawnExecutorFailure as a, DELEGATION_TRACE_MAX_BYTES as at, naiveContinuationPrompt as b, withWorkerSpawnRetry as c, capDelegationTrace as ct, supervisorAgent as d, DelegationPersistenceError as dt, validateDelegateArgs as et, supervisorAgentWithTestBrain as f, DelegationStateCorruptError as ft, dumbContinuationFailPrompt as g, eventToSnapshot as gt, delegatesWorkerBriefPrompt as h, InMemoryFeedbackStore as ht, workerFromBackend as i, hashIdempotencyInput as it, DELEGATION_STATUS_TOOL_NAME as j, DELEGATION_STATUS_DESCRIPTION as k, assertCoordinationBinding as l, composeLoopTraceEmitters as lt, createPromptRegistry as m, InMemoryDelegationStore as mt, supervise as n, delegate as nt, resolveWorkerSpawnRetry as o, DELEGATION_TRACE_MAX_SPANS as ot, analyzesFindingsReportPrompt as p, FileDelegationStore as pt, DELEGATE_FEEDBACK_TOOL_NAME as q, superviseWithTestBrain as r, DelegationTaskQueue as rt, retryPreSpawnRefusals as s, buildDelegationTraceSpans as st, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as t, defaultDelegateBudget as tt, resolveSupervisorProfile as u, createDelegationTraceCollector as ut, formatPromptHandle as v, gateOnDeliverable as vt, classifyDriverFailure as w, promptHandle as x, kernelPromptRegistry as y, mapExecutorResult as yt, delegationProfiles as z };
 
-//# sourceMappingURL=supervise-BUy1cr2L.js.map
+//# sourceMappingURL=supervise-yDiZAqlN.js.map