@tangle-network/agent-runtime 7.0.0 → 8.0.0

package/dist/{supervise-xwl2D6q3.js → supervise-DWiSgPLB.js}

@@ -1,16 +1,17 @@
-import { $r as linkAbort, At as scopeOwnerExecutionObservation, Bt as reconcileScopeRetainedOwnerEnvironment, Ct as scopeRetainedOwnerPriorSpend, Dt as noteScopeOwnerPlannedExecution, En as WORKER_TRACE_PROPAGATION, Er as recordRuntimeOwnedDriveHarnessProviderEvidence, Fr as runtimeOwnedPendingExecutorMaterialization, Ft as runtimeGraphMetadataKey, Gt as bindScopeRetainedOwnerProvider, Hr as isRuntimeFlowBrain, Ht as noteScopeRetainedOwnerCoordination, In as createOtelExporter, It as beginScopeRetainedOwnerDrive, Kt as scopeRetainedOwnerContext, Lr as runtimeOwnedScopeOwnerRuntime, M as parseWorkerToolTraceArtifact, Mr as runtimeOwnedExecutorExecutionBinding, Mt as coordinationMcpAlias, Nr as runtimeOwnedExecutorMaterialization, Nt as coordinationProfileToolPrefix, Ot as recordScopeOwnerMaterialization, Pr as runtimeOwnedExecutorProviderEvidence, Pt as providerVisibleProfile, Rn as generateSpanId, Rt as scopeRetainedOwnerTurnEnded, St as prepareScopeRetainedOwnerTask, Tr as providerAttemptEvidence, Tt as beginScopeOwnerAttempt, Ur as runtimeFlowAgent, Vt as scopeRetainedOwnerRestorePoint, Wr as runtimeFlowBrain, Wt as bindScopeRetainedOwnerEnvironmentId, Xn as persistHarnessTranscript, Zn as readHarnessTranscript, Zr as RunCancellationReason, _r as attestRuntimeOwnedScopeOwner, _t as scopeRetainedOwnerResourceReader, a as createRootStreamSink, an as executorObservationSeamKey, at as recordScopeOwnerDriverAttempt, bt as abandonScopeRetainedOwnerInvocation, cr as SEAT_RECHECK_MS, dr as authoredSeatStages, ei as runAbortable, fr as seatExecutionProfile, gt as releaseScopeRetainedOwnerForSeatPause, ht as prepareScopeRetainedOwnerSeatSwitch, i as ROOT_STREAM_FILE, it as recordScopeOwnerBarrenPause, jr as runtimeOwnedDriveHarnessProviderEvidence, jt as scopeOwnerExecutorNodeContext, kt as restoreScopeOwnerAcceptedExecution, lr as SeatChain, nt as meterRuntimeOwnedProviderAttempt, or as isLiveNodeStatus, ot as recordScopeOwnerPause, q as assertRecursiveReservationPolicy, qt as scopeRetainedOwnerJournalRoot, rr as createActivityLog, rt as pauseScopeSeatAdmission, s as readRootStream, sr as isTerminalNodeStatus, tt as meterRuntimeOwnedAccounting, ur as SeatPauseError, vr as authoredAgentIdentity, wt as scopeRetainedOwnerResult, xt as consumeScopeRetainedOwnerResult, zt as assertRetainedOwnerCoordinationRekey } from "./supervisor-accounting-DxLQ_TQe.js";
-import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError } from "./errors-AzSuGI23.js";
-import { A as withBudgetResources, D as addResourceSpend, I as armDeadlineTimer, P as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, S as unmeteredSpend, T as zeroSpend, V as teardownExecutor, c as errorMessage, f as isAsyncIterable, i as chargedTokens, k as resourceTelemetry, m as promptCacheTokenClasses, n as addSpend, v as sleep, w as withTimeout, z as isDeadlineAbortReason } from "./util-C_cdPNC4.js";
-import { $ as assertValidBudget, C as jitteredMs, D as unavailableResumeAt, E as unavailablePauseMs, L as turnFailureOf, M as contentAddress, P as executorFailure, Q as spendFromUsageTotals, R as turnFailurePolicy, S as cappedDoublingMs, T as reportedResetAt, X as newUsageTotals, Y as meterUsageEvent, _ as registerRetainedExecutorPreparation, u as RetainedExecutionPendingError, wt as recordValue, y as retainedExecutorSeamKey } from "./failure-cause-rJTm_Tx8.js";
-import { a as errMessage, c as errorText, i as causeChain, l as defaultRedactor, n as detachedSnapshot, o as errorHttpStatus } from "./snapshot-Cgj2Wzi6.js";
-import { $t as renderUnsupported, B as createRouterTranscript, C as createExecutor, Ct as bestComposite, F as codeModeArguments, Gt as assertProfileMaterialization, I as codeModeModelOutput, Jt as defineProfileMaterializationContract, L as createCodeModeTools, Lt as bridgeRuntimeAttachmentsKey, Ot as bridgeAdmissionRefusal, Qt as promptModelProfileMaterialization, Rt as bridgeStopSignalKey, S as captureReusableExecutorConfig, St as admitContinuationPolicy, Tt as createContinuationKeeper, U as resolveAgentEnvironmentProvider, V as routerBrain, X as createInbox, Xt as profileMaterializationAxes$1, Y as INBOX_RECEIPT_KEY, Yt as fullProfileMaterialization, Zt as promptControlProfileMaterialization, _t as gateFactoryOnDeliverable, a as assertRunParking, c as sleepScopeWait, ct as HarnessTurnFailedError, d as runFinalizer, dt as summarizeDriverAttempts, et as PEER_MAIL_WIRE_KEY, f as runTree, ft as transientFailureKind, g as isDriverSpec, gt as CheckUnavailableError, h as driverExecutorFactory, ht as preflightPublicCoordination, i as RunParkedError, kt as bridgeModelRouteRefusal, l as withRunParking, lt as abandonablePending, m as driverChild, mt as upstreamUnavailableSignal, n as createSupervisor, nn as unsupportedProfileDimensions, o as bindScopeParkingDrain, p as createRootHandle, pt as undispatchedCredentialExit, qt as controlProfileMaterialization, rn as worktreeCliProfileMaterialization, rt as isPeerMailEnvelope, st as DriverAttemptsExhaustedError, tn as sandboxProfileMaterialization, u as bestDelivered, ut as classifyDriverFailure, w as snapshotExecutorConfig, wt as checkVerdictOf, x as bindReusableExecutorExecutionId, xt as CONTINUATIONS_DIR, z as toolResultText } from "./supervisor-gC-u_PRk.js";
-import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, l as profileProviderModel, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile, v as harnessRunsAgent } from "./model-policy-JOcg3NRs.js";
-import { n as createStdioToolServer } from "./tool-server-Dg350Bgz.js";
+import { Ar as providerAttemptEvidence, At as noteScopeOwnerPlannedExecution, Br as runtimeOwnedPendingExecutorMaterialization, Cr as authoredAgentIdentity, Ct as abandonScopeRetainedOwnerInvocation, Dt as scopeRetainedOwnerResult, Et as scopeRetainedOwnerPriorSpend, F as parseWorkerToolTraceArtifact, Ft as coordinationMcpAlias, Gt as noteScopeRetainedOwnerCoordination, Hr as runtimeOwnedScopeOwnerRuntime, Ht as assertRetainedOwnerCoordinationRekey, Ir as runtimeOwnedDriveHarnessProviderEvidence, It as coordinationProfileToolPrefix, Jt as bindScopeRetainedOwnerProvider, Lr as runtimeOwnedExecutorExecutionBinding, Lt as providerVisibleProfile, Mt as restoreScopeOwnerAcceptedExecution, Nt as scopeOwnerExecutionObservation, Ot as beginScopeOwnerAttempt, Pt as scopeOwnerExecutorNodeContext, Rr as runtimeOwnedExecutorMaterialization, Rt as runtimeGraphMetadataKey, Sr as attestRuntimeOwnedScopeOwner, Tt as prepareScopeRetainedOwnerTask, Un as generateSpanId, Ut as reconcileScopeRetainedOwnerEnvironment, Vn as createOtelExporter, Vt as scopeRetainedOwnerTurnEnded, Wt as scopeRetainedOwnerRestorePoint, X as assertRecursiveReservationPolicy, Xr as runtimeFlowBrain, Xt as scopeRetainedOwnerContext, Yr as runtimeFlowAgent, Yt as owners, Zt as scopeRetainedOwnerJournalRoot, _r as seatExecutionProfile, a as createRootStreamSink, at as meterRuntimeOwnedProviderAttempt, bt as scopeRetainedOwnerResourceReader, cr as createActivityLog, ct as recordScopeOwnerDriverAttempt, dr as isLiveNodeStatus, fr as isTerminalNodeStatus, gr as authoredSeatStages, hr as SeatPauseError, i as ROOT_STREAM_FILE, ii as RunCancellationReason, it as meterRuntimeOwnedAccounting, jn as WORKER_TRACE_PROPAGATION, jr as recordRuntimeOwnedDriveHarnessProviderEvidence, jt as recordScopeOwnerMaterialization, ln as executorObservationSeamKey, lt as recordScopeOwnerPause, mr as SeatChain, nr as readHarnessTranscript, oi as linkAbort, ot as pauseScopeSeatAdmission, pr as SEAT_RECHECK_MS, qr as isRuntimeFlowBrain, qt as bindScopeRetainedOwnerEnvironmentId, s as readRootStream, si as runAbortable, st as recordScopeOwnerBarrenPause, tr as persistHarnessTranscript, vt as prepareScopeRetainedOwnerSeatSwitch, wt as consumeScopeRetainedOwnerResult, yt as releaseScopeRetainedOwnerForSeatPause, zr as runtimeOwnedExecutorProviderEvidence, zt as beginScopeRetainedOwnerDrive } from "./supervisor-accounting-Bw4MJk-b.js";
+import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError } from "./errors-DG8yufqX.js";
+import { A as withBudgetResources, D as addResourceSpend, I as armDeadlineTimer, P as DEFAULT_SUCCESSFUL_SHUTDOWN_MS, S as unmeteredSpend, T as zeroSpend, V as teardownExecutor, c as errorMessage, f as isAsyncIterable, i as chargedTokens, k as resourceTelemetry, m as promptCacheTokenClasses, n as addSpend, v as sleep, w as withTimeout, z as isDeadlineAbortReason } from "./util-fcckrkKp.js";
+import { $ as spendFromUsageTotals, C as jitteredMs, D as unavailableResumeAt, E as unavailablePauseMs, L as harnessProcessDied, M as contentAddress, P as executorFailure, R as turnFailureOf, S as cappedDoublingMs, T as reportedResetAt, Tt as recordValue, X as meterUsageEvent, Z as newUsageTotals, _ as registerRetainedExecutorPreparation, et as assertValidBudget, u as RetainedExecutionPendingError, y as retainedExecutorSeamKey, z as turnFailurePolicy } from "./failure-cause-CVB-YE88.js";
+import { a as errMessage, c as errorStack, i as causeChain, l as errorText, n as detachedSnapshot, o as errorHttpStatus, u as defaultRedactor } from "./snapshot-BKI_w3JD.js";
+import { At as bridgeRuntimeAttachmentsKey, B as createRouterTranscript, Bt as controlProfileMaterialization, C as createExecutor, F as codeModeArguments, Gt as promptModelProfileMaterialization, Ht as fullProfileMaterialization, I as codeModeModelOutput, Jt as sandboxProfileMaterialization, Kt as renderUnsupported, L as createCodeModeTools, Rt as assertProfileMaterialization, S as captureReusableExecutorConfig, St as bridgeModelRouteRefusal, U as resolveAgentEnvironmentProvider, Ut as profileMaterializationAxes$1, V as routerBrain, Vt as defineProfileMaterializationContract, Wt as promptControlProfileMaterialization, X as createInbox, Xt as worktreeCliProfileMaterialization, Y as INBOX_RECEIPT_KEY, Yt as unsupportedProfileDimensions, _t as gateFactoryOnDeliverable, a as assertRunParking, c as sleepScopeWait, ct as HarnessTurnFailedError, d as runFinalizer, dt as summarizeDriverAttempts, et as PEER_MAIL_WIRE_KEY, f as runTree, ft as transientFailureKind, g as isDriverSpec, gt as CheckUnavailableError, h as driverExecutorFactory, ht as preflightPublicCoordination, i as RunParkedError, jt as bridgeStopSignalKey, l as withRunParking, lt as abandonablePending, m as driverChild, mt as upstreamUnavailableSignal, n as createSupervisor, o as bindScopeParkingDrain, p as createRootHandle, pt as undispatchedCredentialExit, rt as isPeerMailEnvelope, st as DriverAttemptsExhaustedError, u as bestDelivered, ut as classifyDriverFailure, w as snapshotExecutorConfig, x as bindReusableExecutorExecutionId, xt as bridgeAdmissionRefusal, z as toolResultText } from "./supervisor-Dpeu7rnZ.js";
+import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, l as profileProviderModel, n as assertModelAllowed, o as enforceTokenLimits, r as assertProfileModelsAllowed, s as profileBridgeWireModel, t as assertExecutableAgentProfile, v as harnessRunsAgent } from "./model-policy-yxOrDTTj.js";
+import { a as createContinuationKeeper, i as checkVerdictOf, n as admitContinuationPolicy, r as bestComposite, t as CONTINUATIONS_DIR } from "./continuation-CIyKnS1Q.js";
+import { n as createStdioToolServer } from "./tool-server-DYwRbi0I.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-CsW2pfFk.js";
-import { _ as workerAssignmentNamespace, c as writeRunCancellation, d as coordinationEventId, f as externalExecutionId, g as supervisionRunNamespace, h as rootCoordinationOwner, i as readRunCancellation, l as canonicalExecution, m as freezeDetachedProfile, p as freezeDetached, r as readRunCancelRequest, s as watchRunCancellation, t as applyRunCancellation, u as childCoordinationOwner } from "./run-cancellation-B84X8ZAP.js";
-import { c as createSteerAcknowledger, d as coordinationVerbNames, f as createFileRunContext, l as budgetOverspendText, m as withRunContext, n as createCoordinationToolsForManager, p as createInMemoryRunContext, s as createCancelAcknowledger, t as createCoordinationTools, u as normalizeAnalyzeOnSettle } from "./coordination-manager-DQZ2u6L-.js";
-import { o as safeJsonText } from "./coordination-map-routing-CKRNZSaV.js";
-import { a as graphRegistry, c as loadGraph } from "./graph-registry-7X2nrreR.js";
+import { _ as workerAssignmentNamespace, c as writeRunCancellation, d as coordinationEventId, f as externalExecutionId, g as supervisionRunNamespace, h as rootCoordinationOwner, i as readRunCancellation, l as canonicalExecution, m as freezeDetachedProfile, p as freezeDetached, r as readRunCancelRequest, s as watchRunCancellation, t as applyRunCancellation, u as childCoordinationOwner } from "./run-cancellation-DYszFJtQ.js";
+import { c as createSteerAcknowledger, d as coordinationVerbNames, f as createFileRunContext, l as budgetOverspendText, m as withRunContext, n as createCoordinationToolsForManager, p as createInMemoryRunContext, s as createCancelAcknowledger, t as createCoordinationTools, u as normalizeAnalyzeOnSettle } from "./coordination-manager-sa_PkISw.js";
+import { o as safeJsonText } from "./coordination-map-routing-XZXTlCmn.js";
+import { a as graphRegistry, c as loadGraph } from "./graph-registry-czAwYwNj.js";
 import { ATTR, LINK_KIND_ATTR, agentIdentityAttributes } from "@tangle-network/agent-trace-contract";
 import { ProxySecretScopeSchema, ProxySecretsSchema, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, mergeProxySecretBindings, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
@@ -30,6 +31,7 @@ const superviseOptionKeySet = /* @__PURE__ */ new Set([
 	"analyzeOnSettle",
 	"mapOnSettle",
 	"routeFlow",
+	"checkNodes",
 	"decideGate",
 	"authorizeMessage",
 	"authorizeSpawn",
@@ -179,6 +181,7 @@ Object.freeze([...superviseExecutableOptionKeys]);
 const superviseReferenceOptionKeys = /* @__PURE__ */ new Set([
 	...superviseExecutableOptionKeys,
 	"blobs",
+	"checkNodes",
 	"hooks",
 	"journal",
 	"otel",
@@ -943,39 +946,9 @@ function renderAnytimeTable(report) {
 }
 // src/runtime/supervise/stop-rules.ts
 /**
-*
-* PROGRESS-BASED STOP RULES — end a long-horizon run for the right reason.
-*
-* Every existing bound is a CEILING: iterations, tokens, dollars, an absolute deadline, a turn
-* cap. A ceiling answers "may this run continue?" and never "is this run still getting anywhere?".
-* So a supervision tree that stopped learning at settle 4 keeps buying workers until it hits a
-* wall — the run ends on exhaustion, and the operator cannot tell a run that finished from a run
-* that ran out.
-*
-* A stop rule reads the run's own PROGRESS and decides. Three signals feed it:
-*   - the objective curve over settled work (best-so-far, from `anytime.ts` — see below),
-*   - the LIVE worker feed (`WorkerProgress`: `idleMs`, `stalled`, `turns`, `tokens`),
-*   - tree-level shape (how many are in flight, when the last settle landed).
-*
-* ── Two boundaries this module holds deliberately ───────────────────────────────────────────────
-*
-* ENFORCEMENT lives here; THRESHOLDS do not. "Stop after 5 settles with no improvement" is a
-* judgment about a domain — how noisy its scores are, how expensive a worker is, how much a late
-* breakthrough is worth. That belongs to the caller (a loop, a bench, a product). Every rule below
-* takes its thresholds as required options with no hidden defaults for the numbers that decide;
-* the module ships the MECHANISM and refuses to ship the judgment.
-*
-* A stop rule can only ADD a stop, never remove one. The driver evaluates the hard ceilings
-* (`poolStarved`, `deadlinePassed`, abort, the driver's own stop) FIRST and independently; the
-* rule is consulted only when they all say "continue". So no rule can talk a run past its budget.
-*
-* ── What is reused, not re-derived ──────────────────────────────────────────────────────────────
-*
-* `anytime.ts` already computed best-so-far curves, their area, and plateau detection — but only
-* after a run was over, from waterfall spans. Rather than write a second copy for the live path,
-* `bestSoFar` / `areaUnderCurve` / `plateauLength` were extracted there and are imported here. A
-* stop rule that calls a run plateaued therefore agrees, number for number, with the report that
-* later judges whether stopping was right.
+* Stop rules only add a stop, and only after the hard ceilings say continue. Thresholds are
+* required caller options. `bestSoFar`, `areaUnderCurve`, and `plateauLength` come from
+* `anytime.ts`.
 *
 * @experimental
 */
@@ -1466,8 +1439,8 @@ function validateGraphTopology(nodes, edges, registry, analysts) {
 	const roots = [...new Set(delegates.map((edge) => edge.from))].filter((id) => !delegatedTo.has(id));
 	if (roots.length !== 1) throw new ValidationError(`runGraph: expected exactly ONE root (a node that delegates and is never delegated to), found ${roots.length === 0 ? "none — delegates edges form a cycle with no entry" : roots.join(", ")}. P0 executes driver↔worker(s); nested driver graphs are P3.`);
 	const root = requireNode(roots[0], "root resolution");
-	if (root.profile.tools?.[`${coordinationProfileToolPrefix}spawn_worker`] !== true) throw new ValidationError(`runGraph: root node '${root.id}' has delegates edges but does not declare ${JSON.stringify(`${coordinationProfileToolPrefix}spawn_worker`)} — the graph cannot spawn any declared worker`);
-	for (const edge of delegates) if (edge.from !== root.id) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from a non-root node — P0 executes one driver over its workers (the 2-node cyclic case, star-generalized); deeper delegation is P3`);
+	const spawnTool = `${coordinationProfileToolPrefix}spawn_worker`;
+	for (const edge of delegates) if (requireNode(edge.from, edgeId(edge)).profile.tools?.[spawnTool] !== true) throw new ValidationError(`runGraph: ${edgeId(edge)} delegates from '${edge.from}', which does not declare ${JSON.stringify(spawnTool)} — only a node holding the spawn tool can start workers`);
 	const analystIds = /* @__PURE__ */ new Set();
 	const analystNodes = /* @__PURE__ */ new Map();
 	for (const edge of analyzes) {
@@ -1575,8 +1548,8 @@ function validateMaps(maps, graph) {
 function graphRootProfile(validated, registry) {
 	const { root, workers, delegatesByWorker, analyzes, analystNodes, maps, mapItemNames } = validated;
 	const driverAnalyzesBriefs = analyzes.filter((edge) => edge.to === root.id).map((edge) => analystNodes.has(edge.analyst) ? `Findings from analyst '${edge.analyst}' (a tool-equipped analyst agent node, over: ${edge.over.join(", ")}) will arrive as finding events.` : `Findings from analyst '${edge.analyst}' (over: ${edge.over.join(", ")}) will arrive as finding events.\n${registry.resolve(edge.directive).text}`);
-	const workerLines = [...workers.values()].map((node) => {
-		const edge = delegatesByWorker.get(node.id);
+	const workerLines = [...delegatesByWorker.values()].filter((edge) => edge.from === root.id).map((edge) => {
+		const node = workers.get(edge.to);
 		const cap = edge.maxTraversals ?? 32;
 		const description = typeof node.profile.description === "string" && node.profile.description.length > 0 ? ` — ${node.profile.description}` : "";
 		const continuityNote = edge.continuity === "resume" ? "; continuity: resume — each spawn after the first re-attaches to this node's latest settled session (spawn again to continue it; steer while it is live)" : "";
@@ -2320,6 +2293,8 @@ function pinDelegatesSpawn({ validated, registry, ledger }, input, requested) {
 	const node = requested !== void 0 ? validated.workers.get(requested) : void 0;
 	if (!node) throw new ValidationError(`runGraph: spawn_worker named profile ${JSON.stringify(requested)} which is not a worker node of this graph (nodes: ${[...validated.workers.keys()].join(", ")}). Spawn by node id: profile.name selects the node; the node profile itself is pinned by the graph.`);
 	const edge = validated.delegatesByWorker.get(node.id);
+	const spawner = ledger.nodeByWorkerId.get(input.parentNodeId ?? "") ?? validated.root?.id;
+	if (spawner !== edge.from) throw new ValidationError(`runGraph: '${spawner}' spawned '${node.id}', but its delegates edge starts at '${edge.from}'`);
 	const id = edgeId(edge);
 	const cap = edge.maxTraversals ?? 32;
 	const spawnContinuity = input.continuity ?? "fresh";
@@ -2381,7 +2356,8 @@ function pinRouteSpawn({ validated: { flow }, registry }, input, requested) {
 	const edge = flow?.routes.get(marker.edge);
 	const starts = flow?.starts.get(marker.edge)?.has(requested) === true;
 	if (node === void 0 || marker.node !== requested || !starts) throw new ValidationError(`runGraph: route spawn for ${JSON.stringify(marker.edge)} names ${JSON.stringify(requested)}, which is not the node that edge starts`);
-	return edge === void 0 ? node.profile : withDirective(node.profile, registry.resolve(edge.directive).text);
+	const reentry = edge?.continuity === "resume" && flow?.entries.some((e) => e.node === requested);
+	return edge === void 0 || reentry ? node.profile : withDirective(node.profile, registry.resolve(edge.directive).text);
 }
 function analystRoutes({ analyzes, analystNodes, root }, registry) {
 	return analyzes.map((edge) => {
@@ -4371,12 +4347,10 @@ function bindServedTools(opts, coord, fenceMs) {
 	if (!Array.isArray(opts.toolNames)) throw new ValidationError("serveCoordinationMcp: toolNames must name every granted tool explicitly");
 	const selectedNames = opts.toolNames;
 	if (new Set(selectedNames).size !== selectedNames.length) throw new ValidationError("serveCoordinationMcp: toolNames contains a duplicate name");
+	const missing = selectedNames.filter((name) => !availableByName.has(name));
+	if (missing.length > 0) throw new ValidationError(`serveCoordinationMcp: requested tools ${missing.map((n) => JSON.stringify(n)).join(", ")} are unavailable; served: ${[...availableByName.keys()].join(", ")}`);
 	return {
-		servedTools: selectedNames.map((name) => {
-			const tool = availableByName.get(name);
-			if (tool === void 0) throw new ValidationError(`serveCoordinationMcp: requested tool ${JSON.stringify(name)} is unavailable`);
-			return tool;
-		}),
+		servedTools: selectedNames.map((name) => availableByName.get(name)),
 		background: () => nodeTools.background() + fencedVerbs.background()
 	};
 }
@@ -5217,10 +5191,12 @@ var DriverRetryLoop = class {
 	}
 	failureRecord(failure) {
 		const producerFailure = turnFailureOf(failure.error);
+		const stack = errorStack(failure.error);
 		return {
 			attempt: failure.attempt,
 			durationMs: failure.durationMs,
 			error: errMessage(failure.error),
+			...stack === void 0 ? {} : { errorStack: stack },
 			...producerFailure === void 0 ? {} : { failure: producerFailure },
 			classification: failure.classification,
 			...failure.classification === "transient" ? { failureKind: transientFailureKind(failure.error) } : {},
@@ -5630,13 +5606,13 @@ async function runDriverWithRetry(run) {
 	}
 }
 // src/runtime/supervise/reentry.ts
-/** Continuity when nothing is proven: compose the full state. */
+/** What a re-entry may assume when nothing proved its session, environment or workspace. */
 const UNPROVEN_CONTINUITY = Object.freeze({
 	session: "new",
 	environment: "unknown",
 	workspace: "unknown"
 });
-/** Compose the task for one re-entered drive. */
+/** The task a re-entered driver receives: what changed, why it re-entered, and its objective. */
 function composeReentryTask(input) {
 	const { reentry, continuity, state } = input;
 	if (reentry.reason === "unmet-contract" && continuity.session === "continued") {
@@ -5690,28 +5666,21 @@ function composeReentryTask(input) {
 		"Your coordination tools are served by the same coordinator as before, and the state above comes from it."
 	].join("\n");
 }
-/**
-* Why the driver is back, in one clause. The failure's own text stays in the attempt records and
-* never reaches the driver: a continuation told the details of a provider
-* failure spent two of its first four children probing the infrastructure, while its peer, told
-* only what to continue, spent all forty-five on the research.
-*/
 function whyLine(reentry) {
 	if (reentry.reason === "unmet-contract") return `Your previous turn ended with the completion check unmet (continuation ${reentry.continuation}).`;
 	if (reentry.reason === "wake") return "Your previous turn ended while your workers ran, and Runtime woke you with what happened.";
 	if (reentry.reason === "run-reentered") return restartLine(reentry);
 	return reentry.reason === "upstream-unavailable" ? "Your previous turn was interrupted before it finished; the run itself is intact." : `Your previous turn ended before it finished (retry ${reentry.retry}); the run itself is intact.`;
 }
-/**
-* What a root re-entered after a barren pause is told: its last turns delivered nothing, and how
-* to wait on long work of its own instead of ending the turn. Measured 2026-10-21 on
-* magnetar-rust-20261021a: the root ended two turns to wait on its own 2^20 prove, and both
-* counted as barren.
-*/
 function barrenLines(reentry) {
 	if (reentry.barren === void 0) return [];
 	const minutes = Math.round(reentry.barren.pausedMs / 6e4);
-	return [`Your last ${reentry.barren.streak} turns ended with the check unmet and delivered nothing: no accepted result, no worker that passed its check, and no rise in the check's score. Runtime waited ${minutes} minutes before this turn.`, "If you are waiting on long work of your own, such as a build, a proof or a job you started, do not end your turn to wait for it. Wait inside the turn with your wake or wait tool, or a command that blocks until the work finishes, then act on its result. Each turn in a row that ends with nothing delivered doubles the wait before the next, up to an hour."];
+	const unjudged = reentry.steer.includes("has not judged") && reentry.steer.includes("verdict reaches you");
+	return [`Your last ${reentry.barren.streak} turns ended with the check unmet and delivered nothing: no accepted result, no worker that passed its check, and no rise in the check's score. Runtime waited ${minutes} minutes before this turn.`, unjudged ? [
+		"The check has not judged this run yet, and its verdict reaches you as feedback.",
+		"End your turn and let that verdict wake you.",
+		"Do not sleep, poll, or record another release to poke the check."
+	].join(" ") : "If you are waiting on long work of your own, such as a build, a proof or a job you started, do not end your turn to wait for it. Wait inside the turn with your wake or wait tool, or a command that blocks until the work finishes, then act on its result. Each turn in a row that ends with nothing delivered doubles the wait before the next, up to an hour."];
 }
 function restartLine(reentry) {
 	const replaced = new Set(reentry.replaced);
@@ -5921,10 +5890,7 @@ function managerFinalizer(deps, session) {
 		...finalizerDeliverable ? { deliverable: finalizerDeliverable } : {}
 	});
 }
-/**
-* Drive the manager's harness until its retry loop ends, and report the loop. Returns the checked
-* candidate a turn that ended with the contract declared and no work open selected.
-*/
+/** Drive until the retry loop ends. Return the checked candidate when the contract is met. */
 async function driveManagerTurns(inputs) {
 	const { config, session } = inputs;
 	const { deps, driveHarness } = config;
@@ -6012,14 +5978,7 @@ async function driveManagerTurns(inputs) {
 	}
 	return loop.candidate;
 }
-/**
-* The stop-pause of an opted-in ROOT (`SupervisorAgentDeps.pauseRootStops`, which `supervise()`
-* sets on the root's deps alone); a nested manager keeps its stops and settles `down` for its
-* parent. A root steer between turns reaches the coordinator as a lead message, and one an ended
-* invocation still held waits in `nextTurnInbox`. Either ends a pause once and stays queued for
-* the next turn: a steer that turn never read, or a pool still spent, would otherwise end every
-* later pause at once.
-*/
+/** Root-only. A nested manager keeps its stops. One steer ends one pause and stays queued. */
 function rootStopPause(config, session) {
 	if (config.deps.pauseRootStops !== true) return {};
 	const { controls } = session;
@@ -6101,11 +6060,7 @@ function readManagerProgress(loop) {
 		...composite === void 0 ? {} : { composite }
 	};
 }
-/**
-* The check runs when a turn ends without an accepted result. A read already taken in this turn
-* stands (the manager just heard it); otherwise a check that judges state reads the run now. A
-* check that could not run is not a verdict: the loop pauses.
-*/
+/** A check already read this turn stands. A check that could not run is not a verdict. */
 async function readCheckAtTurnEnd(loop, attempt) {
 	const deliverable = loop.config.deps.deliverable;
 	const { controls } = loop.session;
@@ -6150,6 +6105,8 @@ async function driveManagerTurn(loop, attempt, reentry) {
 	const { deps, runtimeToolNames } = loop.config;
 	const { mcp, controls, state } = loop.session;
 	const { scope, task } = state;
+	const owner = owners.get(scope);
+	if (owner) owner.replaceDeadExecution = reentry?.reason === "driver-failure" && harnessProcessDied(reentry.failure);
 	loop.candidate = void 0;
 	if (deps.controlDir !== void 0 && deps.abortRun !== void 0) applyRunCancellation(deps.controlDir, deps.abortRun, () => (/* @__PURE__ */ new Date()).toISOString());
 	scope.signal.throwIfAborted();
@@ -6653,15 +6610,8 @@ function supervisorAgentWithTestBrain(profile, deps) {
 	return buildSupervisorAgent(profile, runtimeDeps, brain);
 }
 // src/runtime/supervise/supervise-profile-admission.ts
-/**
-* NOT a harness-name test — `ExecutorConfig.backend` is a discriminated-union TAG naming HOW a
-* profile is materialized (bridge / sandbox / cli-worktree / cli-in-place / router / cli /
-* provider), which is a
-* different axis from WHICH CLI runs. An exhaustive switch on a closed union tag is the correct
-* shape and must stay: it is what makes a new executor kind a compile error here rather than a
-* silently weaker materialization contract. Every other `backend.backend === …` in this file and
-* in `runtime.ts` is the same tag; none of them are harness names.
-*/
+/** `ExecutorConfig.backend` names HOW a profile is materialized, not which CLI runs; the exhaustive
+*  switch makes a new executor kind a compile error rather than a weaker contract. */
 function backendProfileMaterialization(backend) {
 	switch (backend.backend) {
 		case "bridge":
@@ -6669,8 +6619,11 @@ function backendProfileMaterialization(backend) {
 		case "sandbox": return sandboxProfileMaterialization;
 		case "cli-worktree": return backend.bridge ? fullProfileMaterialization : worktreeCliProfileMaterialization;
 		case "cli-in-place": return worktreeCliProfileMaterialization;
-		case "router":
-		case "router-tools": return promptModelProfileMaterialization;
+		case "router": return promptModelProfileMaterialization;
+		case "router-tools": return {
+			name: "router-tools-execution",
+			axes: [...promptModelProfileMaterialization.axes, "tools"]
+		};
 		case "cli": return controlProfileMaterialization;
 	}
 }
@@ -7103,15 +7056,25 @@ function workerFromBackend(backend, deliverable, seams) {
 		const boundSessionId = boundBackend.backend === "bridge" ? boundBackend.sessionId : void 0;
 		const peerMailAttachment = peerMailRuntimeAttachment(profile, capturedBackend, spawnContext);
 		if (spawnContext?.peerMailUrl && boundBackend.backend === "provider" && Object.hasOwn(boundBackend.defaults?.runtimeAttachments?.mcp ?? {}, "agent-runtime-peer-mail")) throw new ValidationError("workerFromBackend: provider defaults contain the reserved peer-mail attachment alias");
-		const leafBackend = spawnContext?.peerMailUrl && boundBackend.backend === "provider" ? {
+		const sizedBackend = spawnContext?.resources !== void 0 && boundBackend.backend === "provider" ? {
 			...boundBackend,
-			steering: boundBackend.steering ?? {},
 			defaults: {
-				...boundBackend.defaults ?? {},
+				...boundBackend.defaults,
+				resources: {
+					...boundBackend.defaults?.resources,
+					...spawnContext.resources
+				}
+			}
+		} : boundBackend;
+		const leafBackend = spawnContext?.peerMailUrl && sizedBackend.backend === "provider" ? {
+			...sizedBackend,
+			steering: sizedBackend.steering ?? {},
+			defaults: {
+				...sizedBackend.defaults ?? {},
 				runtimeAttachments: {
-					...boundBackend.defaults?.runtimeAttachments ?? {},
+					...sizedBackend.defaults?.runtimeAttachments ?? {},
 					mcp: {
-						...boundBackend.defaults?.runtimeAttachments?.mcp ?? {},
+						...sizedBackend.defaults?.runtimeAttachments?.mcp ?? {},
 						[peerMailMcpAlias]: {
 							transport: "http",
 							url: spawnContext.peerMailUrl
@@ -7119,9 +7082,13 @@ function workerFromBackend(backend, deliverable, seams) {
 					}
 				}
 			}
-		} : boundBackend;
-		const rawFactory = createExecutor(leafBackend);
-		const baseFactory = deliverable ? gateFactoryOnDeliverable(rawFactory, deliverable) : rawFactory;
+		} : sizedBackend;
+		const analyst = spawnContext?.analyst !== void 0;
+		const rawFactory = createExecutor(analyst && "validator" in leafBackend ? {
+			...leafBackend,
+			validator: void 0
+		} : leafBackend);
+		const baseFactory = deliverable && !analyst ? gateFactoryOnDeliverable(rawFactory, deliverable) : rawFactory;
 		const executorFactory = (spec, ctx) => {
 			if (boundSessionId !== void 0 && ctx.node?.nodeId !== void 0) bridgeSessionByWorker.set(ctx.node.nodeId, boundSessionId);
 			const extraSeams = seams?.();
@@ -7315,14 +7282,16 @@ function recursiveWorkerFactoryFor(env, seat) {
 	const makeRecursiveWorker = (authoredProfile, spawnContext, recovering = false) => {
 		if (!spawnContext) throw new ValidationError("supervise: backend-derived workers require spawn context");
 		const admitted = admitSpawn(env, seat, authoredProfile, spawnContext, recovering);
-		return admitted.usesRuntimeCoordination ? managedWorker(env, seat, admitted, spawnContext) : leafWorker(env, seat, admitted, spawnContext);
+		return admitted.usesRuntimeCoordination ? managedWorker(env, seat, admitted, spawnContext) : leafWorker(env, seat, admitted, spawnContext, recovering);
 	};
 	registerRecovery(env, makeRecursiveWorker);
 	return makeRecursiveWorker;
 }
-function leafWorker(env, seat, admitted, spawnContext) {
+function leafWorker(env, seat, admitted, spawnContext, recovering) {
 	const { options, deliverable, runNamespace } = env.setup;
 	const { childDeliverable } = admitted;
+	const name = admitted.authorized.name ?? "";
+	if (options.checkNodes?.names.includes(name) && seat.depth === 1 && (recovering || spawnContext.route?.node === name)) return options.checkNodes.leaf(admitted.authorized, admitted.authorizedContext);
 	if (childDeliverable !== 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 withModelSubstitution((childDeliverable === deliverable ? env.makeLeaf : workerFromBackend(options.backend, childDeliverable))(admitted.authorized, Object.freeze({
 		...admitted.authorizedContext,
@@ -8786,6 +8755,25 @@ function composeSpawnPreflights(...preflights) {
 		}
 	};
 }
+/** Refuse a `spawn_worker` machine request that the backend's `maxWorkerResources` does not admit
+*  (#1277): a request is refused, never clamped, and the refusal names the ceiling. */
+function resourceSpawnPreflight(backend) {
+	return async (_profile, { resources }) => {
+		if (resources === void 0) return void 0;
+		const ceiling = backend?.backend === "provider" ? backend.maxWorkerResources : void 0;
+		const over = [
+			"cpu",
+			"memoryMb",
+			"diskMb",
+			"gpu"
+		].filter((k) => resources[k] !== void 0 && (k === "gpu" ? resources.gpu !== ceiling?.gpu : !(resources[k] <= (ceiling?.[k] ?? 0))));
+		if (over.length === 0) return void 0;
+		return {
+			cause: "unprovisionable-profile",
+			detail: `resources ${over.map((k) => `${k}=${resources[k]}`).join(", ")} exceed this run's maxWorkerResources ${JSON.stringify(ceiling ?? {})}`
+		};
+	};
+}
 // src/runtime/supervise/supervise-sql-admission.ts
 /** What a SQL run context admits, in two phases: identity and worker seam before any compute (a
 *  synchronous configuration fault), then coordinator and retained-control capabilities at start. */
@@ -9036,13 +9024,15 @@ function managerDriverPlan(options, canonicalProfile, externalRoot) {
 	if (authoredSeatStages(canonicalProfile) && !hasCustomDriveHarness && !options.selectSeat) throw new ValidationError("supervise: AgentProfile.seats requires selectSeat before execution");
 	const automaticDriver = managerBackend !== void 0 && automaticDriverBackendSupported(managerBackend, options.coordination);
 	const spawnResourceRoot = hasCustomDriveHarness ? void 0 : rootSpawnResourceRoot(managerBackend);
-	const spawnPreflight = composeSpawnPreflights(async (profile, context) => {
+	const agentPreflight = composeSpawnPreflights(async (profile, context) => {
 		const external = isExternalSupervisor(profile);
 		const manager = declaredRuntimeToolNames(profile).length > 0 || external && authoredSeatStages(profile) !== void 0;
 		const custom = manager ? external && hasCustomDriveHarness : options.makeLeafAgent !== void 0;
 		const backend = manager ? external ? managerBackend : void 0 : options.backend;
 		return modelSettingsSpawnPreflight(options.makeWorkerAgent === void 0 && !custom, backend?.backend === "provider" ? "provider" : "router")?.(profile, context);
-	}, profileToolSpawnPreflight(options.makeWorkerAgent === void 0, options.resolveSupervisorTools !== void 0), coordinationChannelSpawnPreflight(options.makeWorkerAgent === void 0, hasCustomDriveHarness, managerBackend, options.coordination), options.backend?.backend === "bridge" ? bridgeSpawnPreflight(options.backend) : void 0, options.backend?.backend === "provider" && typeof options.backend.provider === "object" ? providerSpawnPreflight(options.backend.provider) : void 0);
+	}, profileToolSpawnPreflight(options.makeWorkerAgent === void 0, options.resolveSupervisorTools !== void 0), coordinationChannelSpawnPreflight(options.makeWorkerAgent === void 0, hasCustomDriveHarness, managerBackend, options.coordination), options.backend?.backend === "bridge" ? bridgeSpawnPreflight(options.backend) : void 0, options.backend?.backend === "provider" && typeof options.backend.provider === "object" ? providerSpawnPreflight(options.backend.provider) : void 0, resourceSpawnPreflight(options.backend));
+	const checkNames = options.checkNodes?.names;
+	const spawnPreflight = agentPreflight && checkNames ? (profile, context) => checkNames.includes(profile.name ?? "") && !profile.harness && !profile.model ? Promise.resolve(void 0) : agentPreflight(profile, context) : agentPreflight;
 	const driverMaterialization = hasCustomDriveHarness ? options.driveHarnessMaterialization ?? fullProfileMaterialization : managerBackend && automaticDriver ? backendProfileMaterialization(managerBackend) : void 0;
 	if (externalRoot && !hasCustomDriveHarness && !automaticDriver) throw new ValidationError(`supervise: external supervisor profile.harness=${JSON.stringify(canonicalProfile.harness)} requires a local bridge, a provider with authenticated coordination.publicUrl and runtime MCP attachments, or an explicit driveHarness with reachable coordination transport`);
 	return {
@@ -9409,4 +9399,4 @@ function superviseWithContext(profile, task, opts, brain) {
 }
 export { dumbContinuationPassPrompt as A, areaUnderCurve as B, defaultEdgeTraversalCap as C, createPromptRegistry as D, analyzesFindingsReportPrompt as E, allWorkersStalled as F, plateauLength as H, anyOf as I, noProgressFor as L, kernelPromptRegistry as M, naiveContinuationPrompt as N, delegatesWorkerBriefPrompt as O, promptHandle as P, plateau as R, validateFlowGraph as S, validateGraphTopology as T, renderAnytimeTable as U, bestSoFar as V, createSupervisorSpanRecorder as W, GraphRouteError as _, superviseRootProfile as a, journaledGateDecider as b, supervisorAgentWithTestBrain as c, composeReentryTask as d, serveCoordinationMcp as f, createGraphOverlay as g, runBrainLoop as h, profileGuidanceComposer as i, formatPromptHandle as j, dumbContinuationFailPrompt as k, runToolSpans as l, driverAgent as m, superviseFleetCapabilities as n, workerFromBackend as o, coordinationControlToolNames as p, superviseWithTestBrain as r, supervisorAgent as s, supervise as t, UNPROVEN_CONTINUITY as u, createFlowRun as v, graphRootProfile as w, routeFlowOf as x, flowRootProfile as y, anytimeReport as z };
 
-//# sourceMappingURL=supervise-xwl2D6q3.js.map
+//# sourceMappingURL=supervise-DWiSgPLB.js.map