@tangle-network/agent-runtime 0.342.1 → 0.343.2

package/dist/{supervise-C_GAgiJU.js → supervise-DyCUu8Io.js}

@@ -1,93 +1,23 @@
-import { n as assertNoSymlinkDescendant } from "./durable-file-gNI9ILAn.js";
-import { $ as noteScopeRetainedOwnerCoordination, $n as CONTINUATIONS_DIR, $r as runtimeOwnedExecutorProviderEvidence, A as providerVisibleProfile, Ai as assertValidBudget, Ar as fullProfileMaterialization, At as toolResultText, B as recordScopeOwnerBarrenPause, Bn as classifyDriverFailure, Br as attestRuntimeOwnedScopeOwner, C as beginScopeOwnerAttempt, Ci as executorFailure, D as scopeOwnerExecutorNodeContext, Di as newUsageTotals, Dn as isPeerMailEnvelope, Dt as codeModeModelOutput, E as restoreScopeOwnerAcceptedExecution, Ei as meterUsageEvent, Er as assertProfileMaterialization, Et as codeModeArguments, Fn as isTerminalNodeStatus, G as consumeScopeRetainedOwnerResult, Gn as SeatChainExhaustedError, H as recordScopeOwnerPause, Hn as undispatchedCredentialExit, In as DriverAttemptsExhaustedError, Ir as sandboxProfileMaterialization, J as scopeRetainedOwnerResult, Jr as providerAttemptEvidence, Jt as readHarnessTranscript, K as prepareScopeRetainedOwnerTask, Kn as authoredSeatStages, Ln as HarnessTurnFailedError, Lr as unsupportedProfileDimensions, Mn as createActivityLog, Mr as promptControlProfileMaterialization, Mt as routerBrain, N as assertRecursiveReservationPolicy, Nr as promptModelProfileMaterialization, O as coordinationMcpAlias, Or as controlProfileMaterialization, Ot as createCodeModeTools, P as deriveNodeExecutionIdentity, Pn as isLiveNodeStatus, Pr as renderUnsupported, Pt as resolveAgentEnvironmentProvider, Q as scopeRetainedOwnerRestorePoint, Qr as runtimeOwnedExecutorMaterialization, R as meterRuntimeOwnedAccounting, Rn as abandonablePending, Rr as worktreeCliProfileMaterialization, Si as contentAddress, T as recordScopeOwnerMaterialization, U as prepareScopeRetainedOwnerSeatSwitch, Un as upstreamUnavailableSignal, V as recordScopeOwnerDriverAttempt, Vn as summarizeDriverAttempts, Vr as authoredAgentIdentity, W as abandonScopeRetainedOwnerInvocation, Wn as SeatChain, Wr as inheritRuntimeOwnedExecutorAttestation, X as scopeRetainedOwnerTurnEnded, Xn as gateOnDeliverable, Xr as runtimeOwnedDriveHarnessProviderEvidence, Y as beginScopeRetainedOwnerDrive, Yn as CheckUnavailableError, Yr as recordRuntimeOwnedDriveHarnessProviderEvidence, Z as reconcileScopeRetainedOwnerEnvironment, Zr as runtimeOwnedExecutorExecutionBinding, _r as runAbortable, a as runTree, bn as createInbox, br as bridgeStopSignalKey, c as driverExecutorFactory, cn as createOtelExporter, di as registerRetainedExecutorPreparation, ei as runtimeOwnedPendingExecutorMaterialization, er as admitContinuationPolicy, et as bindScopeRetainedOwnerEnvironmentId, fi as retainedExecutorSeamKey, ft as bindReusableExecutorExecutionId, gi as unavailableResumeAt, gr as linkAbort, hi as unavailablePauseMs, hr as RunCancellationReason, ht as snapshotExecutorConfig, i as runFinalizer, it as scopeRetainedOwnerJournalRoot, j as runtimeGraphMetadataKey, jr as profileMaterializationAxes$1, jt as createRouterTranscript, k as coordinationProfileToolPrefix, ki as spendFromUsageTotals, kr as defineProfileMaterializationContract, l as isDriverSpec, m as parseWorkerToolTraceArtifact, mi as jitteredMs, mn as toOtelAttributes, mt as createExecutor, n as createSupervisor, nr as checkVerdictOf, nt as owners, o as createRootHandle, or as bridgeAdmissionRefusal, pi as cappedDoublingMs, pt as captureReusableExecutorConfig, q as scopeRetainedOwnerPriorSpend, qn as seatExecutionProfile, qt as persistHarnessTranscript, r as bestDelivered, rr as createContinuationKeeper, rt as scopeRetainedOwnerContext, s as driverChild, sr as bridgeModelRouteRefusal, ti as runtimeOwnedScopeOwnerRuntime, tn as WORKER_TRACE_PROPAGATION, tr as bestComposite, tt as bindScopeRetainedOwnerProvider, ui as RetainedExecutionPendingError, un as generateSpanId, w as noteScopeOwnerPlannedExecution, wi as errMessage, wn as PEER_MAIL_WIRE_KEY, xi as detachedSnapshot, yn as INBOX_RECEIPT_KEY, yr as bridgeRuntimeAttachmentsKey, z as meterRuntimeOwnedProviderAttempt, zn as causedByPartialFailure } from "./supervisor-C_03z693.js";
+import { c as __exportAll, n as assertNoSymlinkDescendant, o as writeAtomicDurableFile, s as sha256 } from "./durable-file-CA0kr1Pi.js";
+import { $ as beginScopeRetainedOwnerDrive, $n as upstreamUnavailableSignal, A as coordinationProfileToolPrefix, An as createInbox, Ar as bridgeStopSignalKey, B as meterRuntimeOwnedProviderAttempt, Bi as assertValidBudget, Br as fullProfileMaterialization, Bt as toolResultText, Ci as cappedDoublingMs, Ct as captureReusableExecutorConfig, D as restoreScopeOwnerAcceptedExecution, Dr as runAbortable, E as recordScopeOwnerMaterialization, Ei as unavailableResumeAt, Er as linkAbort, F as deriveNodeExecutionIdentity, G as scopeRetainedOwnerResourceReader, Gn as isTerminalNodeStatus, H as recordScopeOwnerDriverAttempt, Hn as createActivityLog, Hr as promptControlProfileMaterialization, Ht as routerBrain, Ii as meterUsageEvent, Ir as assertProfileMaterialization, It as codeModeArguments, J as abandonScopeRetainedOwnerInvocation, Jn as abandonablePending, Jr as worktreeCliProfileMaterialization, Kn as DriverAttemptsExhaustedError, Kr as sandboxProfileMaterialization, Li as newUsageTotals, Ln as isPeerMailEnvelope, Lt as codeModeModelOutput, M as runtimeGraphMetadataKey, Mi as contentAddress, Ni as executorFailure, O as scopeOwnerExecutorNodeContext, P as assertRecursiveReservationPolicy, Pi as errMessage, Pn as PEER_MAIL_WIRE_KEY, Q as scopeRetainedOwnerResult, Qn as undispatchedCredentialExit, Rr as controlProfileMaterialization, Rt as createCodeModeTools, Si as retainedExecutorSeamKey, St as bindReusableExecutorExecutionId, T as noteScopeOwnerPlannedExecution, Ti as unavailablePauseMs, Tr as RunCancellationReason, Tt as snapshotExecutorConfig, U as recordScopeOwnerPause, Ur as promptModelProfileMaterialization, V as recordScopeOwnerBarrenPause, Vr as profileMaterializationAxes$1, Vt as createRouterTranscript, W as prepareScopeRetainedOwnerSeatSwitch, Wn as isLiveNodeStatus, Wr as renderUnsupported, Wt as resolveAgentEnvironmentProvider, X as prepareScopeRetainedOwnerTask, Xn as classifyDriverFailure, Xr as attestRuntimeOwnedScopeOwner, Y as consumeScopeRetainedOwnerResult, Yn as causedByPartialFailure, Z as scopeRetainedOwnerPriorSpend, Zn as summarizeDriverAttempts, Zr as authoredAgentIdentity, _r as bridgeModelRouteRefusal, _t as readCommittedJsonLines, a as runFinalizer, ai as recordRuntimeOwnedDriveHarnessProviderEvidence, ar as CheckUnavailableError, at as bindScopeRetainedOwnerProvider, bi as RetainedExecutionPendingError, bn as generateSpanId, c as driverChild, ci as runtimeOwnedExecutorMaterialization, di as runtimeOwnedScopeOwnerRuntime, dn as WORKER_TRACE_PROPAGATION, dr as bestComposite, ei as inheritRuntimeOwnedExecutorAttestation, er as SeatChain, et as scopeRetainedOwnerTurnEnded, fr as checkVerdictOf, gr as bridgeAdmissionRefusal, gt as readCommittedJsonFile, h as parseWorkerToolTraceArtifact, ht as prepareJsonlAppend, i as bestDelivered, ii as providerAttemptEvidence, in as readHarnessTranscript, it as bindScopeRetainedOwnerEnvironmentId, j as providerVisibleProfile, ji as detachedSnapshot, k as coordinationMcpAlias, kn as INBOX_RECEIPT_KEY, kr as bridgeRuntimeAttachmentsKey, l as driverExecutorFactory, li as runtimeOwnedExecutorProviderEvidence, lr as CONTINUATIONS_DIR, mt as isNoEntError, n as createSupervisor, nr as authoredSeatStages, nt as scopeRetainedOwnerRestorePoint, o as runTree, oi as runtimeOwnedDriveHarnessProviderEvidence, or as gateOnDeliverable, ot as scopeRetainedOwnerContext, pr as createContinuationKeeper, qn as HarnessTurnFailedError, qr as unsupportedProfileDimensions, rn as persistHarnessTranscript, rr as seatExecutionProfile, rt as noteScopeRetainedOwnerCoordination, s as createRootHandle, si as runtimeOwnedExecutorExecutionBinding, st as scopeRetainedOwnerJournalRoot, tr as SeatChainExhaustedError, tt as reconcileScopeRetainedOwnerEnvironment, u as isDriverSpec, ui as runtimeOwnedPendingExecutorMaterialization, ur as admitContinuationPolicy, vn as createOtelExporter, vt as upsertCommittedJsonLine, w as beginScopeOwnerAttempt, wi as jitteredMs, wn as toOtelAttributes, wt as createExecutor, xi as registerRetainedExecutorPreparation, yt as withJsonlFileLock, z as meterRuntimeOwnedAccounting, zi as spendFromUsageTotals, zr as defineProfileMaterializationContract } from "./supervisor-gDn4C1o5.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError } from "./errors-DodWX-cb.js";
-import { t as isRecord } from "./record-value-B6bwJxLa.js";
-import { Et as isDeadlineAbortReason, K as chargedTokens, Ot as teardownExecutor, W as addSpend, X as errorMessage, _t as withBudgetResources, dt as withTimeout, et as isAsyncIterable, ft as zeroSpend, gt as resourceTelemetry, kt as teardownSurfaces, mt as addResourceSpend, nt as promptCacheTokenClasses, ot as sleep, ut as unmeteredSpend, xt as DEFAULT_SUCCESSFUL_SHUTDOWN_MS } from "./sandbox-profile-compat-FN2kab2-.js";
+import { Et as isDeadlineAbortReason, K as chargedTokens, Ot as teardownExecutor, W as addSpend, X as errorMessage, _t as withBudgetResources, dt as withTimeout, et as isAsyncIterable, ft as zeroSpend, gt as resourceTelemetry, kt as teardownSurfaces, mt as addResourceSpend, nt as promptCacheTokenClasses, ot as sleep, ut as unmeteredSpend, xt as DEFAULT_SUCCESSFUL_SHUTDOWN_MS } from "./sandbox-profile-compat-_fEtHPCj.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-CyCUwHed.js";
 import { t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { a as readCommittedJsonLines, n as isNoEntError, r as prepareJsonlAppend } from "./jsonl-file-C9Kde_0Z.js";
-import { _ as environmentReader, c as budgetOverspendText, d as safeJsonText, f as createFileRunContext, l as normalizeAnalyzeOnSettle, m as withRunContext, n as createCoordinationToolsForManager, o as createCancelAcknowledger, p as createInMemoryRunContext, s as createSteerAcknowledger, t as createCoordinationTools, u as coordinationVerbNames } from "./coordination-manager-HQE0bIav.js";
-import { a as watchRunCancellation, i as readRunCancellation, o as writeRunCancellation, r as readRunCancelRequest, t as applyRunCancellation } from "./run-cancellation-C9oL62sW.js";
+import { c as budgetOverspendText, d as safeJsonText, f as createFileRunContext, l as normalizeAnalyzeOnSettle, m as withRunContext, n as createCoordinationToolsForManager, o as createCancelAcknowledger, p as createInMemoryRunContext, s as createSteerAcknowledger, t as createCoordinationTools, u as coordinationVerbNames } from "./coordination-manager-DIC19cgD.js";
+import { c as writeRunCancellation, i as readRunCancellation, r as readRunCancelRequest, s as watchRunCancellation, t as applyRunCancellation } from "./run-cancellation-DSpwvFmQ.js";
 import { n as createStdioToolServer, t as PROTOCOL_VERSION } from "./tool-server-XV4aJwoQ.js";
-import { c as loadGraph, i as graphRegistry } from "./graph-registry-BnO64cn8.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
+import { isRecord } from "@tangle-network/agent-core";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { closeSync, constants, fsyncSync, openSync, writeSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { mkdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { mkdir, readFile, readdir } from "node:fs/promises";
 import { isMaterializerHarness } from "@tangle-network/agent-profile-materialize";
 import { createServer } from "node:http";
 import { ATTR, agentIdentityAttributes } from "@tangle-network/agent-trace-contract";
 import { withProfileKb } from "@tangle-network/agent-interface/profile-kb";
-//#region src/runtime/supervise/retained-owner-resource-reader.ts
-/**
-* The owner's environment as a source of by-path spawn resources.
-*
-* Built once per scope, before the environment exists: the coordination tools are created ahead
-* of the owner's first turn, and the environment is admitted during it. So the reader resolves
-* its target on every read — the latest environment admission on this node, reconstructed through
-* the bound provider the same way cleanup reconstructs it, with the same identity check. A manager
-* that has not yet been admitted, or whose provider was never bound, gets a refusal that names the
-* missing piece rather than a read from nowhere.
-*
-* The environment's `read()` serves the sandbox's own workspace; containment against that
-* workspace is the provider's. The relative-path and `..` rules are the reader's, in
-* `environmentReader`, so a manager is refused for the rule it broke.
-*/
-function scopeRetainedOwnerResourceReader(scope) {
-	const state = owners.get(scope);
-	if (state === void 0) return void 0;
-	const latestEnvironmentId = () => state.liveEnvironmentId?.() ?? [...state.admissions].reverse().flatMap((admission) => admission.phase === "environment" ? [admission.environmentId] : [])[0];
-	return {
-		get describe() {
-			return `environment ${latestEnvironmentId() ?? "<not yet admitted>"}`;
-		},
-		async read(path) {
-			const provider = state.provider;
-			if (provider === void 0) return {
-				ok: false,
-				reason: "the manager’s environment provider is not bound yet"
-			};
-			const environmentId = latestEnvironmentId();
-			if (environmentId === void 0) return {
-				ok: false,
-				reason: "the manager’s environment has not been admitted yet"
-			};
-			if (!provider.get) return {
-				ok: false,
-				reason: `provider ${provider.name} cannot reconstruct the manager’s environment`
-			};
-			let environment;
-			try {
-				environment = await provider.get(environmentId);
-			} catch (error) {
-				return {
-					ok: false,
-					reason: `environment ${environmentId}: ${error instanceof Error ? error.message : String(error)}`
-				};
-			}
-			if (environment === null) return {
-				ok: false,
-				reason: `environment ${environmentId} is gone`
-			};
-			if (environment.id !== environmentId || environment.provider !== provider.name) return {
-				ok: false,
-				reason: `provider returned another environment for ${environmentId}`
-			};
-			if (typeof environment.read !== "function") return {
-				ok: false,
-				reason: `environment ${environmentId} does not expose read; its provider cannot serve a resource by path`
-			};
-			const read = environment.read.bind(environment);
-			return environmentReader({
-				id: environment.id,
-				read
-			}).read(path);
-		}
-	};
-}
-//#endregion
 //#region src/runtime/supervise/supervise-identity.ts
 function externalExecutionId(kind, identity) {
 	return `${kind}-${canonicalCandidateDigest({
@@ -5127,6 +5057,16 @@ const DEFAULT_MAX_BACKOFF_MS$1 = 3e4;
 const DEFAULT_TRANSIENT_OUTAGE_MS = 9e5;
 const BARREN_PAUSE_FIRST_MS = 5 * 6e4;
 const BARREN_PAUSE_MAX_MS = 60 * 6e4;
+/** The stops an opted-in root pauses on (`DriverRetryRun.stopPause`). `completed`, `aborted` and a
+*  declared `deadline` end the run; `supervise()` refuses `driverRetry.pauseRootStops` beside `retry-disabled`. */
+const PAUSED_STOPS = /* @__PURE__ */ new Set([
+	"terminal-error",
+	"no-progress",
+	"max-attempts",
+	"repeated-failure",
+	"pending-unresolved",
+	"budget-exhausted"
+]);
 /**
 * The pause before a continuation once `streak` re-entered drives in a row have completed without
 * progress: 5 minutes at `maxBarren`, doubling per further barren drive, 60 minutes at most.
@@ -5175,6 +5115,10 @@ function budgetStop(budget, atMs) {
 	if (budget.usdCapped && budget.usdKnown === false) return "budget-exhausted";
 	if (Object.values(budget.resources ?? {}).some((resource) => !resource.known || resource.remaining <= 0)) return "budget-exhausted";
 }
+/** The cause an admission or continuation refusal carries: it has no failure of its own. */
+function admissionError(stop) {
+	return new ValidationError(`driver admission: ${stop}`);
+}
 function contractOf(mark) {
 	return mark.contract ?? "none";
 }
@@ -5227,6 +5171,7 @@ var DriverRetryLoop = class {
 	sameFailure;
 	samePartial;
 	abandonments = 0;
+	stopPauses = 0;
 	pauses = 0;
 	continuations = 0;
 	wakes = 0;
@@ -5250,13 +5195,100 @@ var DriverRetryLoop = class {
 		this.attempts.push(stamped);
 		await this.run.onAttempt?.(stamped);
 	}
-	/** True when the loop returns before this attempt; throws when no attempt ever completed. */
-	admissionRefused() {
+	/**
+	* Whether the next attempt may run: `undefined` admits it, `'refused'` returns before it, and a
+	* stop is one an opted-in root pauses on before asking again. Throws when no attempt ever
+	* completed. Synchronous, so nothing separates an admitted attempt from its dispatch.
+	*/
+	admission() {
 		const { run } = this;
 		const admissionStop = run.signal.aborted ? abortStop(run.signal) : budgetStop(run.budget(), this.limits.now());
-		if (admissionStop === void 0) return false;
-		if (this.attempts.length > 0) return true;
-		throw new DriverAttemptsExhaustedError(run.signal.aborted ? run.signal.reason : new ValidationError(`driver admission: ${admissionStop}`), this.attempts, admissionStop);
+		if (admissionStop === void 0) return void 0;
+		if (this.pausesStop(admissionStop)) return admissionStop;
+		if (this.attempts.length > 0) return "refused";
+		throw new DriverAttemptsExhaustedError(run.signal.aborted ? run.signal.reason : admissionError(admissionStop), this.attempts, admissionStop);
+	}
+	/** Pause an opted-in root where admission would have stopped it; the re-entry is kept. */
+	async pauseAdmission(stop, attempt) {
+		await this.stopPause(admissionError(stop), stop, {
+			attempt,
+			durationMs: 0,
+			madeProgress: false
+		});
+	}
+	/** True when `stop` becomes a pause: the caller opted in, the stop is one the header names, and
+	*  neither the run nor the manager's own stop has fired. */
+	pausesStop(stop) {
+		const { run } = this;
+		return run.stopPause !== void 0 && PAUSED_STOPS.has(stop) && !run.signal.aborted && run.stopSignal?.aborted !== true;
+	}
+	/** End the loop on `stop` with `record` (when the stop has one), or pause an opted-in root. */
+	async stopOrPause(error, stop, record) {
+		if (!this.pausesStop(stop)) {
+			await this.emit({
+				...record,
+				stop
+			});
+			throw new DriverAttemptsExhaustedError(error, this.attempts, stop);
+		}
+		await this.stopPause(error, stop, record);
+	}
+	/** The earlier of the continuation deadline and the budget's deadline; infinite when neither is set. */
+	deadlineAt() {
+		const budgetDeadline = this.run.budget().deadlineMs;
+		return Math.min(this.run.continuation?.deadlineMs ?? Number.POSITIVE_INFINITY, budgetDeadline > 0 ? budgetDeadline : Number.POSITIVE_INFINITY);
+	}
+	/**
+	* The wait an opted-in root takes where it would stop (STOP-PAUSE in `./driver-retry.ts`). Emits
+	* one record carrying `replacesStop`, sleeps until the ladder ends, a cancel or a root steer, and
+	* resets the per-window counters. A cancel during the pause emits one `aborted` record and
+	* throws; so does a declared deadline the pause reached. A failure re-enters as `driver-failure`.
+	*/
+	async stopPause(error, stop, record) {
+		const { run, limits } = this;
+		const steering = run.stopPause;
+		if (steering === void 0) throw new DriverAttemptsExhaustedError(error, this.attempts, stop);
+		this.stopPauses += 1;
+		const pausedAt = limits.now();
+		const pauseMs = Math.max(0, Math.min(cappedDoublingMs(this.stopPauses, BARREN_PAUSE_FIRST_MS, BARREN_PAUSE_MAX_MS), this.deadlineAt() - pausedAt));
+		await this.emit({
+			...record,
+			replacesStop: stop,
+			stopPauseStreak: this.stopPauses,
+			retryInMs: pauseMs,
+			resumeAt: new Date(pausedAt + pauseMs).toISOString()
+		});
+		const steered = new AbortController();
+		const wait = AbortSignal.any([run.signal, steered.signal]);
+		steering.steered(wait).then(() => steered.abort());
+		try {
+			await limits.sleep(pauseMs, wait);
+		} finally {
+			steered.abort();
+		}
+		const ended = run.signal.aborted ? abortStop(run.signal) : limits.now() >= this.deadlineAt() ? "deadline" : void 0;
+		if (ended !== void 0) {
+			await this.emit({
+				attempt: record.attempt,
+				durationMs: 0,
+				madeProgress: false,
+				stop: ended
+			});
+			throw new DriverAttemptsExhaustedError(error, this.attempts, ended);
+		}
+		this.chargedFailures = 0;
+		this.consecutiveBarren = 0;
+		this.sameFailure = void 0;
+		this.samePartial = void 0;
+		this.samePending = void 0;
+		this.abandonments = 0;
+		this.outageSince = void 0;
+		if (record.error !== void 0) this.reentry = {
+			reason: "driver-failure",
+			failure: errMessage(error),
+			retry: this.failures,
+			pausedMs: pauseMs
+		};
 	}
 	failureRecord(failure) {
 		return {
@@ -5271,16 +5303,17 @@ var DriverRetryLoop = class {
 		const { run } = this;
 		if (run.signal.aborted) throw new DriverAttemptsExhaustedError(error, this.attempts, abortStop(run.signal));
 		const afterWait = budgetStop(run.budget(), this.limits.now());
-		if (afterWait) throw new DriverAttemptsExhaustedError(error, this.attempts, afterWait);
+		if (afterWait && !this.pausesStop(afterWait)) throw new DriverAttemptsExhaustedError(error, this.attempts, afterWait);
 	}
 	/** Read a failed drive, then pause or retry it, or throw the stop that ends the loop. */
 	async afterFailure(error, attempt, before, startedAt) {
 		const durationMs = this.limits.now() - startedAt;
-		const classification = classifyDriverFailure(error, this.run.signal);
+		const classification = classifyDriverFailure(error, this.run.signal, this.run.stopSignal);
 		const after = this.run.progress();
 		const progressed = madeProgress(before, after);
 		if (progressed) {
 			this.abandonments = 0;
+			this.stopPauses = 0;
 			this.lastProgressAt = this.limits.now();
 		}
 		const pending = abandonablePending(error);
@@ -5313,12 +5346,11 @@ var DriverRetryLoop = class {
 		})();
 		const unavailableSignal = upstreamUnavailableSignal(error) ?? "unavailable";
 		if (stop !== void 0) {
-			await this.emit({
+			await this.stopOrPause(error, stop, {
 				...this.failureRecord(failure),
-				unavailableSignal,
-				stop
+				unavailableSignal
 			});
-			throw new DriverAttemptsExhaustedError(error, this.attempts, stop);
+			return;
 		}
 		this.pauses += 1;
 		this.consecutivePauses = progressed ? 1 : this.consecutivePauses + 1;
@@ -5357,12 +5389,11 @@ var DriverRetryLoop = class {
 		const retryStop = abandoned ? void 0 : unresolved ? "pending-unresolved" : stop;
 		if (progressed) this.barrenReentries = 0;
 		if (retryStop !== void 0) {
-			await this.emit({
+			await this.stopOrPause(error, retryStop, {
 				...this.failureRecord(failure),
-				stop: retryStop,
 				...retainedFailure === void 0 ? {} : { pendingCause: retainedFailure.pendingCause }
 			});
-			throw new DriverAttemptsExhaustedError(error, this.attempts, retryStop);
+			return;
 		}
 		if (!abandoned) this.consecutiveBarren = progressed ? 0 : this.consecutiveBarren + 1;
 		const backoff = jitteredMs(cappedDoublingMs(this.consecutiveBarren, limits.initialBackoff, limits.maxBackoff), limits.random);
@@ -5476,9 +5507,7 @@ var DriverRetryLoop = class {
 		if (this.barrenReentries < policy.maxBarren) return void 0;
 		const { run } = this;
 		const pausedAt = this.limits.now();
-		const budgetDeadline = run.budget().deadlineMs;
-		const until = Math.min(policy.deadlineMs ?? Number.POSITIVE_INFINITY, budgetDeadline > 0 ? budgetDeadline : Number.POSITIVE_INFINITY);
-		const pauseMs = Math.max(0, Math.min(barrenPauseMs(this.barrenReentries, policy.maxBarren), until - pausedAt));
+		const pauseMs = Math.max(0, Math.min(barrenPauseMs(this.barrenReentries, policy.maxBarren), this.deadlineAt() - pausedAt));
 		const pause = {
 			attempt,
 			streak: this.barrenReentries,
@@ -5516,11 +5545,21 @@ var DriverRetryLoop = class {
 		};
 		if (progressed) {
 			this.barrenReentries = 0;
+			this.stopPauses = 0;
 			this.lastProgressAt = this.limits.now();
 		} else if (!this.beforeModelEvent && this.reentry !== void 0 && this.reentry.reason !== "wake" && contract === "unmet") this.barrenReentries += 1;
 		if (run.wait !== void 0 && contract !== "met" && await this.wake(attempt, completed)) return true;
 		if (contract === "unmet" && continuation !== void 0) {
-			const decision = await this.decideContinuation(continuation, attempt, after);
+			let decision = await this.decideContinuation(continuation, attempt, after);
+			while ("refusedBy" in decision && decision.refusedBy === "budget-exhausted") {
+				if (!this.pausesStop("budget-exhausted")) break;
+				await this.stopPause(admissionError("budget-exhausted"), "budget-exhausted", {
+					attempt,
+					durationMs,
+					madeProgress: false
+				});
+				decision = await this.decideContinuation(continuation, attempt, after);
+			}
 			if ("steer" in decision) {
 				this.continuations += 1;
 				await this.emit({
@@ -5582,10 +5621,12 @@ var DriverRetryLoop = class {
 * backend reattaches the harness session because the execution id is bound durably per node.
 *
 * Failure classes (all conservative):
-*  - TERMINAL: Runtime's own refusals (`ValidationError`/`ConfigError`, exhausted budget, abort, a
-*    client-side transport status such as 401/404/422). Retrying re-runs a decision. Fails at once.
+*  - TERMINAL: Runtime's own refusals (`ValidationError`/`ConfigError`, exhausted budget, the run's
+*    own abort, a client-side transport status such as 401/404/422). Retrying re-runs a decision.
+*    Fails at once.
 *  - TRANSIENT: everything foreign (harness exit without a reason, a stream cut mid-turn, a 5xx, a
-*    socket reset). A harness turn that RETURNED a failed outcome is the same accident reported as
+*    socket reset, an `AbortError` that neither the run's signal nor the manager's own stop
+*    issued). A harness turn that RETURNED a failed outcome is the same accident reported as
 *    a value, so the drive raises {@link HarnessTurnFailedError} and it is classified like any other.
 *  - UNAVAILABLE: the upstream said "not now" (429, 503, 529, or the router's own codes: quota,
 *    rate limit, overload). The driver PAUSES and re-enters; a pause consumes neither `maxAttempts`
@@ -5648,6 +5689,21 @@ var DriverRetryLoop = class {
 *
 * Every wait, a failure backoff or a pause, is jittered over its upper half so drivers that one
 * outage cut off together do not re-enter together.
+*
+* STOP-PAUSE. A run started with `driverRetry.pauseRootStops` hands its ROOT a `stopPause`;
+* no other manager gets one. It turns every stop except `completed`, `aborted` and a declared `deadline` into a wait that alarms:
+* `terminal-error`, `no-progress`, `max-attempts`, `repeated-failure`, `pending-unresolved` and
+* `budget-exhausted` each emit one record with `replacesStop` and pause 5 minutes, doubling per
+* stop-pause in a row up to 60, never past a declared deadline and not jittered. An attempt that
+* made progress resets the streak. A cancel ends the pause and settles the run; a root steer ends
+* any pause at once, a budget pause included, because a steer is how an operator changes a live
+* run. Ending a pause admits nothing by itself: the next admission reads the pool again, a pool
+* still spent pauses again with its own row, and the steer stays queued until a turn reads it.
+* After the pause the per-window counters start over and the driver is re-entered: after
+* a failure as `driver-failure` with `pausedMs`, after an admission or continuation refusal as the
+* re-entry it was about to use. Drew, 2026-10-21: "why do these runs keep failing early its
+* unacceptable!" Measured 2026-10-21 over 259 runs since 10-14: 8 of the 10 stops settled runs that
+* nobody solved or stopped, including 17 roots whose harness never streamed.
 */
 function assertContinuationPolicy(continuation) {
 	if (continuation === void 0) return;
@@ -5664,7 +5720,8 @@ function assertContinuationPolicy(continuation) {
 * `deadline` when a deadline cut it and `aborted` otherwise, never `terminal-error`. Throws
 * `DriverAttemptsExhaustedError` (cause = the last real failure) when a FAILURE ends the loop; a
 * completed drive returns, met contract or not, because deciding what an undelivered run is worth
-* belongs to the finalizer, not to this loop.
+* belongs to the finalizer, not to this loop. With `stopPause`, every stop but `completed`,
+* `aborted` and a declared `deadline` pauses instead (STOP-PAUSE in the header).
 */
 async function runDriverWithRetry(run) {
 	const limits = driverRetryLimits(run);
@@ -5674,7 +5731,13 @@ async function runDriverWithRetry(run) {
 		const before = run.progress();
 		const startedAt = limits.now();
 		loop.beforeModelEvent = run.reentered !== void 0 && run.reentered.modelEvents() === 0;
-		if (loop.admissionRefused()) return;
+		const admission = loop.admission();
+		if (admission === "refused") return;
+		if (admission !== void 0) {
+			await loop.pauseAdmission(admission, attempt);
+			attempt -= 1;
+			continue;
+		}
 		try {
 			await run.drive(attempt, loop.reentry);
 		} catch (error) {
@@ -5996,7 +6059,8 @@ async function driveManagerTurns(inputs) {
 		workspaceRestores: 0,
 		describe: deps.deliverable?.describe,
 		continuationSession: deps.continuation?.session,
-		modelEvents: 0
+		modelEvents: 0,
+		reported: false
 	};
 	const { mcp } = session;
 	const keeper = session.state.keeper;
@@ -6016,6 +6080,8 @@ async function driveManagerTurns(inputs) {
 			progress: () => readManagerProgress(loop),
 			budget: () => scope.budget,
 			signal: scope.signal,
+			stopSignal: session.state.stopController.signal,
+			...rootStopPause(config, session),
 			resolvePending: (failure, failures) => abandonScopeRetainedOwnerInvocation(scope, failure, failures),
 			wait: {
 				open: () => !mcp.submittedResult() && !mcp.isStopped() && session.state.progressStopReason === void 0 && (session.controls.hasOpenWork() || session.state.nextTurnInbox.pendingAuthority() > 0),
@@ -6034,10 +6100,49 @@ async function driveManagerTurns(inputs) {
 		driverFailed = false;
 	} finally {
 		await driveHarness.closeSeatSegment?.(scope.signal.aborted ? "cancelled" : driverFailed ? "failed" : "completed");
-		reportManagerLoop(loop);
+		if (!loop.reported) reportManagerLoop(loop);
 	}
 	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.
+*/
+function rootStopPause(config, session) {
+	if (config.deps.pauseRootStops !== true) return {};
+	const { controls } = session;
+	const { nextTurnInbox } = session.state;
+	let answeredLead = /* @__PURE__ */ new Set();
+	let answeredInbox = 0;
+	const unanswered = () => controls.queuedLeadMessages().some((seq) => !answeredLead.has(seq)) || nextTurnInbox.pendingAuthority() > answeredInbox;
+	return { stopPause: { steered: async (signal) => {
+		answeredInbox = Math.min(answeredInbox, nextTurnInbox.pendingAuthority());
+		if (!unanswered()) {
+			const listening = new AbortController();
+			const until = AbortSignal.any([signal, listening.signal]);
+			try {
+				await Promise.race([controls.awaitLeadMessage(until), (async () => {
+					while (!until.aborted && !unanswered()) await Promise.race([nextTurnInbox.nextDelivery(), abortedSignal(until)]);
+				})()]);
+			} finally {
+				listening.abort();
+			}
+		}
+		if (signal.aborted || !unanswered()) return;
+		answeredLead = new Set(controls.queuedLeadMessages());
+		answeredInbox = nextTurnInbox.pendingAuthority();
+	} } };
+}
+function abortedSignal(signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) resolve();
+		else signal.addEventListener("abort", () => resolve(), { once: true });
+	});
+}
 function createManagerKeeper(config, session, deliverable, continuation) {
 	const { deps, runtimeToolNames } = config;
 	const { mcp, controls } = session;
@@ -6116,6 +6221,7 @@ async function readCheckAtTurnEnd(loop, attempt) {
 	if (last?.unavailable !== void 0) throw new CheckUnavailableError(`the completion check could not run: ${last.unavailable}`);
 }
 function reportManagerLoop(loop) {
+	loop.reported = true;
 	const { mcp, controls, state } = loop.session;
 	const stopReason = controls.stopReason() ?? state.progressStopReason;
 	const closedBy = mcp.submittedResult() ? "result-accepted" : mcp.isStopped() ? "stop" : state.progressStopReason !== void 0 ? "stop-rule" : void 0;
@@ -6275,8 +6381,20 @@ async function wakeManager(loop, nextAttempt) {
 async function recordManagerAttempt(loop, record) {
 	const { scope } = loop.session.state;
 	loop.records.push(record);
+	if (record.stop !== void 0) reportManagerLoop(loop);
 	await recordScopeOwnerDriverAttempt(scope, record);
-	if (record.classification === "unavailable" && record.retryInMs !== void 0) await recordScopeOwnerPause(scope, {
+	if (record.replacesStop !== void 0 && record.retryInMs !== void 0 && record.stopPauseStreak !== void 0 && record.resumeAt !== void 0) await recordScopeOwnerPause(scope, {
+		attempt: record.attempt,
+		signal: record.replacesStop,
+		cause: record.error ?? record.replacesStop,
+		attemptMs: record.durationMs,
+		pauseMs: record.retryInMs,
+		madeProgress: record.madeProgress,
+		replacesStop: record.replacesStop,
+		streak: record.stopPauseStreak,
+		resumeAt: record.resumeAt
+	});
+	else if (record.classification === "unavailable" && record.retryInMs !== void 0) await recordScopeOwnerPause(scope, {
 		attempt: record.attempt,
 		signal: record.unavailableSignal ?? "unavailable",
 		cause: record.error ?? "",
@@ -7217,6 +7335,194 @@ function admitSpawn(env, seat, authoredProfile, spawnContext, recovering) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/graph-registry.ts
+/**
+* `graph-registry` — the designer's memory: graphs and their outcomes as files.
+*
+* The AgentGraph algebra makes a graph PLAIN DATA (nodes with pinned profiles,
+* edges with registry-versioned directives, a budget, a deliverable
+* description), which is the property that lets a graph be stored, replayed
+* byte-identical, and mutated like code. This module is the thin durable layer
+* on top: one JSONL record per run, the exact graph content-addressed beside
+* it. The natural home is a SANDBOX WORKSPACE — the platform's snapshot story
+* (Firecracker restore, warm leases, `continuity: 'resume'`) then makes the
+* registry the agent's compounding execution memory across runs: a rerun over
+* the same sandbox finds every graph the designer ever ran, what each cost,
+* and whether it delivered.
+*
+* ORACLES STAY ENVIRONMENT-OWNED. `DeliverableSpec.check` is a function and is
+* deliberately NOT stored: a stored graph keeps the deliverable's `describe`
+* and an optional `checkRef`, and replay re-binds the check from the caller's
+* environment. This is the graph contract's own doctrine — graders are
+* environment, never workers — applied to persistence.
+*
+* Scoring is a documented heuristic, not a learned model: delivered beats
+* failed, then cheaper (tokens, then iterations), then most recent. A designer
+* that needs better selection replaces `pickBest`, not the records.
+*/
+var graph_registry_exports = /* @__PURE__ */ __exportAll({
+	digestOfGraph: () => digestOfGraph,
+	graphDigest: () => graphDigest,
+	graphFromStored: () => graphFromStored,
+	graphRegistry: () => graphRegistry,
+	graphRunsFor: () => graphRunsFor,
+	listGraphRuns: () => listGraphRuns,
+	loadGraph: () => loadGraph,
+	lookupGraph: () => lookupGraph,
+	pickBestGraph: () => pickBestGraph,
+	recordGraphRun: () => recordGraphRun,
+	storedGraphDigests: () => storedGraphDigests,
+	taskShapeDigest: () => taskShapeDigest
+});
+const RECORDS_FILE = "records.jsonl";
+const GRAPHS_DIR = "graphs";
+/** Canonical serialization for content-addressing: stable key order, sorted. */
+function canonicalJson$1(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson$1).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson$1(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/** Digest of the exact graph (nodes + edges + budget + deliverable describe, and a flow graph's
+*  entry and gates). An absent key is not serialized, so a graph without `entry` keeps the digest
+*  it had before flow graphs were stored. */
+function graphDigest(graph) {
+	return sha256(canonicalJson$1(graph));
+}
+/** Digest of the normalized task shape a designer looks records up by. */
+function taskShapeDigest(taskShape) {
+	return sha256(canonicalJson$1(taskShape));
+}
+/** Digest of a runnable graph exactly as the registry stores it — the value
+*  `recordGraphRun` demands. Callers recording real runs hash through this,
+*  never hand-rolled, so a record always matches its graph. */
+function digestOfGraph(graph) {
+	return storeGraph(graph).digest;
+}
+function storeGraph(graph) {
+	const content = {
+		nodes: graph.nodes,
+		edges: graph.edges,
+		budget: graph.budget,
+		deliverable: { ...graph.deliverable.describe ? { describe: graph.deliverable.describe } : {} },
+		...graph.entry === void 0 ? {} : { entry: graph.entry },
+		...graph.gates === void 0 ? {} : { gates: graph.gates }
+	};
+	return {
+		digest: graphDigest(content),
+		...content
+	};
+}
+function assertRecord(record) {
+	if (typeof record.graphDigest !== "string" || record.graphDigest.length === 0) throw new ValidationError("graph-registry: record.graphDigest is required");
+	if (typeof record.taskDigest !== "string" || record.taskDigest.length === 0) throw new ValidationError("graph-registry: record.taskDigest is required");
+	if (record.outcome.kind !== "delivered" && record.outcome.kind !== "no-winner") throw new ValidationError("graph-registry: record.outcome.kind must be 'delivered' | 'no-winner'");
+}
+function recordKey(record) {
+	assertRecord(record);
+	return JSON.stringify([
+		record.taskDigest,
+		record.graphDigest,
+		record.startedAt
+	]);
+}
+/** Open (or lazily create) a registry rooted at a workspace directory. The
+*  directory is the sandbox workspace; snapshots carry it across runs. */
+function graphRegistry(root) {
+	if (!root || root.trim().length === 0) throw new ValidationError("graphRegistry: root directory is required");
+	return { root };
+}
+/** Append one run record; the exact graph is content-addressed beside it.
+*  Idempotent per (taskDigest, graphDigest, startedAt): a replayed append with
+*  the same key replaces the prior row rather than duplicating it. */
+async function recordGraphRun(reg, graph, record) {
+	assertRecord(record);
+	const stored = storeGraph(graph);
+	if (stored.digest !== record.graphDigest) throw new ValidationError(`graph-registry: record.graphDigest ${record.graphDigest} does not match the supplied graph (${stored.digest}) — record the graph that actually ran`);
+	await mkdir(join(reg.root, GRAPHS_DIR), { recursive: true });
+	return withJsonlFileLock(join(reg.root, RECORDS_FILE), async (canonicalPath) => {
+		writeAtomicDurableFile(join(reg.root, GRAPHS_DIR, `${stored.digest}.json`), JSON.stringify(stored), { preserveMode: true });
+		await upsertCommittedJsonLine(canonicalPath, record, recordKey);
+		return stored;
+	});
+}
+/** All records, newest last. */
+async function listGraphRuns(reg) {
+	return readCommittedJsonFile(join(reg.root, RECORDS_FILE));
+}
+/** Records for one task shape, newest last. */
+async function graphRunsFor(reg, taskDigest) {
+	return (await listGraphRuns(reg)).filter((row) => row.taskDigest === taskDigest);
+}
+/** The documented heuristic: delivered beats failed; among delivered, cheaper
+*  (tokens, then iterations) wins; ties go to the most recent. */
+function pickBestGraph(records) {
+	const delivered = records.filter((row) => row.outcome.kind === "delivered");
+	if (delivered.length === 0) return void 0;
+	const better = (a, b) => {
+		const aTokens = a.cost.tokens ?? Number.POSITIVE_INFINITY;
+		const bTokens = b.cost.tokens ?? Number.POSITIVE_INFINITY;
+		if (aTokens !== bTokens) return aTokens < bTokens ? a : b;
+		const aIter = a.cost.iterations ?? Number.POSITIVE_INFINITY;
+		const bIter = b.cost.iterations ?? Number.POSITIVE_INFINITY;
+		if (aIter !== bIter) return aIter < bIter ? a : b;
+		return a.finishedAt >= b.finishedAt ? a : b;
+	};
+	return delivered.reduce((best, row) => better(best, row) === best ? best : row);
+}
+/** Load a stored graph by digest. */
+async function loadGraph(reg, digest) {
+	try {
+		return JSON.parse(await readFile(join(reg.root, GRAPHS_DIR, `${digest}.json`), "utf8"));
+	} catch {
+		return;
+	}
+}
+/** The designer's lookup: replay the known-good graph for this task shape, or
+*  author a new one — with the reason stated either way (the decision is data). */
+async function lookupGraph(reg, taskDigest) {
+	const records = await graphRunsFor(reg, taskDigest);
+	const best = pickBestGraph(records);
+	if (best) {
+		const graph = await loadGraph(reg, best.graphDigest);
+		if (graph) return {
+			kind: "replay",
+			graph,
+			record: best
+		};
+		return {
+			kind: "author",
+			reason: `best record's graph ${best.graphDigest.slice(0, 12)} is missing from the registry`
+		};
+	}
+	return {
+		kind: "author",
+		reason: records.length === 0 ? "first run for this task shape" : "no graph delivered for this task shape yet"
+	};
+}
+/** Rehydrate a stored graph into a runnable one. The check comes from the
+*  CALLER's environment (oracles are environment, never stored). */
+function graphFromStored(stored, check) {
+	return {
+		nodes: stored.nodes,
+		edges: stored.edges,
+		budget: stored.budget,
+		deliverable: {
+			check,
+			...stored.deliverable.describe ? { describe: stored.deliverable.describe } : {}
+		},
+		...stored.entry === void 0 ? {} : { entry: stored.entry },
+		...stored.gates === void 0 ? {} : { gates: stored.gates }
+	};
+}
+/** Digests present on disk (integrity probe for tests and audits). */
+async function storedGraphDigests(reg) {
+	try {
+		return (await readdir(join(reg.root, GRAPHS_DIR))).filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -5)).sort();
+	} catch {
+		return [];
+	}
+}
+//#endregion
 //#region src/runtime/supervise/supervise-graph-subtasks.ts
 /** A stored graph's topology, from the registry `SuperviseOptions.graphRegistry` names. */
 async function storedGraphTopology(dir, digest) {
@@ -9180,7 +9486,7 @@ function superviseInternal(profile, task, opts, testBrain) {
 	const workers = createSuperviseWorkers(setup, (reason, request) => cancelDurableRun(reason, request));
 	const durableCancellation = new AbortController();
 	const cancelDurableRun = (reason, request) => {
-		durableCancellation.abort(request === void 0 ? new Error(reason) : new RunCancellationReason(request.source, reason, request.operationId));
+		durableCancellation.abort(request === void 0 ? new Error(reason) : new RunCancellationReason(request.source, reason, request.operationId, request.operator));
 	};
 	return startSupervisedRun({
 		setup,
@@ -9279,6 +9585,7 @@ function rootSupervisorAgent(run, priorCoordination, runDir) {
 		...options.decideGate ? { decideGate: options.decideGate } : {},
 		...options.continuityByProfile ? { continuityByProfile: options.continuityByProfile } : {},
 		...supervisorTurnOptions(options),
+		...options.driverRetry?.pauseRootStops === true ? { pauseRootStops: true } : {},
 		...deliverable && options.continuation && setup.externalRoot ? {
 			continuation: options.continuation,
 			...runDir === void 0 ? {} : {
@@ -9418,6 +9725,7 @@ function superviseWithTestBrain(profile, task, opts) {
 	return superviseWithContext(profile, task, runtimeOptions, brain);
 }
 function superviseWithContext(profile, task, opts, brain) {
+	if (opts.driverRetry?.pauseRootStops === true && opts.driverRetry.enabled === false) throw new ValidationError("supervise: driverRetry.pauseRootStops pauses where a retry would stop; it cannot be combined with driverRetry.enabled: false");
 	if (opts.runContext?.acquire === void 0) return superviseInternal(profile, task, opts, brain);
 	const options = captureSuperviseOptions(opts);
 	const capturedProfile = freezeDetached(profile);
@@ -9429,6 +9737,6 @@ function superviseWithContext(profile, task, opts, brain) {
 	}, brain));
 }
 //#endregion
-export { createPromptRegistry as A, noProgressFor as B, journaledGateDecider as C, graphRootProfile as D, defaultEdgeTraversalCap as E, kernelPromptRegistry as F, plateauLength as G, anytimeReport as H, naiveContinuationPrompt as I, readRootStreamReceipt as J, renderAnytimeTable as K, promptHandle as L, dumbContinuationFailPrompt as M, dumbContinuationPassPrompt as N, validateGraphTopology as O, formatPromptHandle as P, allWorkersStalled as R, flowRootProfile as S, validateFlowGraph as T, areaUnderCurve as U, plateau as V, bestSoFar as W, createSupervisorSpanRecorder as Y, runBrainLoop as _, superviseRootProfile as a, GraphRouteError as b, retryPreSpawnRefusals as c, supervisorAgent as d, supervisorAgentWithTestBrain as f, driverAgent as g, serveCoordinationMcp as h, profileGuidanceComposer as i, delegatesWorkerBriefPrompt as j, analyzesFindingsReportPrompt as k, withWorkerSpawnRetry as l, composeReentryTask as m, superviseFleetCapabilities as n, isPreSpawnExecutorFailure as o, UNPROVEN_CONTINUITY as p, readRootStream as q, superviseWithTestBrain as r, resolveWorkerSpawnRetry as s, supervise as t, workerFromBackend as u, runtimeFlowBrain as v, routeFlowOf as w, createFlowRun as x, createGraphOverlay as y, anyOf as z };
+export { noProgressFor as $, runBrainLoop as A, graphRootProfile as B, workerFromBackend as C, composeReentryTask as D, UNPROVEN_CONTINUITY as E, flowRootProfile as F, dumbContinuationFailPrompt as G, analyzesFindingsReportPrompt as H, journaledGateDecider as I, kernelPromptRegistry as J, dumbContinuationPassPrompt as K, routeFlowOf as L, createGraphOverlay as M, GraphRouteError as N, serveCoordinationMcp as O, createFlowRun as P, anyOf as Q, validateFlowGraph as R, taskShapeDigest as S, supervisorAgentWithTestBrain as T, createPromptRegistry as U, validateGraphTopology as V, delegatesWorkerBriefPrompt as W, promptHandle as X, naiveContinuationPrompt as Y, allWorkersStalled as Z, loadGraph as _, superviseRootProfile as a, renderAnytimeTable as at, recordGraphRun as b, retryPreSpawnRefusals as c, createSupervisorSpanRecorder as ct, graphDigest as d, plateau as et, graphFromStored as f, listGraphRuns as g, graph_registry_exports as h, profileGuidanceComposer as i, plateauLength as it, runtimeFlowBrain as j, driverAgent as k, withWorkerSpawnRetry as l, graphRunsFor as m, superviseFleetCapabilities as n, areaUnderCurve as nt, isPreSpawnExecutorFailure as o, readRootStream as ot, graphRegistry as p, formatPromptHandle as q, superviseWithTestBrain as r, bestSoFar as rt, resolveWorkerSpawnRetry as s, readRootStreamReceipt as st, supervise as t, anytimeReport as tt, digestOfGraph as u, lookupGraph as v, supervisorAgent as w, storedGraphDigests as x, pickBestGraph as y, defaultEdgeTraversalCap as z };
 
-//# sourceMappingURL=supervise-C_GAgiJU.js.map
+//# sourceMappingURL=supervise-DyCUu8Io.js.map