@tangle-network/agent-runtime 0.300.0 → 0.306.1

package/dist/{supervisor-CQSu5XGl.js → supervisor-gCfG6K1-.js}

@@ -1,10 +1,10 @@
 import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, i as ConfigError, l as RetainedInteractiveBindingError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError$1, u as RetainedRunAdmissionError } from "./errors-DodWX-cb.js";
+import { $ as randomUuid, B as addTokenUsage, G as errorMessage, H as cloneSpend, K as fnv1a32Hex, N as deepFreezeCandidate, O as verifyWorkspaceSnapshotArtifacts, Q as randomSuffix, U as cloneTokenUsage, V as chargedTokens, W as deleteBoxSafe, X as mapWithConcurrency, Y as isAsyncIterable$1, Z as promptCacheTokenClasses, _t as armDeadlineTimer, a as verifyAgentCandidateWorkspaceArtifacts, at as unmeteredSpend, bt as singleFlightTeardown, ct as zeroTokenUsage, dt as resourceTelemetry, et as roundBoxMinutes, ft as withBudgetResources, gt as ROOT_DEADLINE_REASON, i as readAgentCandidateWorkspaceArtifactFiles, it as throwIfAborted, k as verifiedArtifactChunks, lt as addResourceSpend, mt as CHILD_DEADLINE_REASON, nt as stringifySafe, o as verifyAgentCandidateWorkspaceTree, ot as withTimeout, pt as ACCEPTED_RESULT_GRACE_MS, q as hasCompleteCacheBreakdown, rt as throwAbort, st as zeroSpend, tt as sleep, u as verifyAgentCandidateWorkspaceArchive, ut as assertResources, vt as boundedChildDeadlineAt, xt as teardownExecutor, yt as isDeadlineAbortReason, z as addSpend } from "./workspace-streams-ILw0eWZ0.js";
 import { runTaskQueue } from "./task-queue.js";
 import { _ as agentHarness, a as concreteProfileModel, c as profileModelExecutionSettings, d as assertRouterAutoDeclaration, f as assertRouterAutoResponse, g as observedModelMatchesDeclared, h as observedModelHasSnapshot, l as profileProviderModel, m as mergeObservedModelIdentity, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-DydyWTQg.js";
-import { D as verifiedArtifactChunks, E as verifyWorkspaceSnapshotArtifacts, c as verifyAgentCandidateWorkspaceArchive, i as verifyAgentCandidateWorkspaceArtifacts, j as deepFreezeCandidate, r as readAgentCandidateWorkspaceArtifactFiles } from "./workspace-streams-D5gHJdTb.js";
 import { n as assertNoSymlinkDescendant, r as publishExclusiveDurableFile } from "./durable-file-DWQA4ooo.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
-import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnInputSchema, AgentTurnResultSchema, CanonicalStreamEventSchema, ContextTransferRequestSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, REASONING_EFFORTS, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentCandidateArtifactRefSchema, agentCandidateWorkspaceManifestMaterialSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalWorkspaceCwd, exactAgentInteractiveSessionStart, harnessTypeSchema, nativeContextContinuationTurnDigest, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema, workspaceCheckpointRequestDigest, workspaceCheckpointResultMatchesRequest, workspaceCleanupAcknowledgementMatches, workspaceCleanupRequestDigest } from "@tangle-network/agent-interface";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnInputSchema, AgentTurnResultSchema, CanonicalStreamEventSchema, ContextTransferRequestSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, REASONING_EFFORTS, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentCandidateArtifactRefSchema, agentCandidateWorkspaceManifestMaterialSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalWorkspaceCwd, exactAgentInteractiveSessionStart, harnessTypeSchema, nativeContextContinuationTurnDigest, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema, workspaceCheckpointRequestDigest, workspaceCheckpointResultMatchesRequest, workspaceCleanupAcknowledgementMatches, workspaceCleanupRequestDigest, workspaceForkRequestDigest, workspaceForkResultMatchesRequest } from "@tangle-network/agent-interface";
 import { estimateCost, isModelPriced, isToolSpan, toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
@@ -102,123 +102,6 @@ function promptPartFromInputPart(part) {
 	};
 }
 //#endregion
-//#region src/runtime/supervise/deadline.ts
-const MAX_TIMER_DELAY_MS = 2147483647;
-const DEFAULT_SUCCESSFUL_SHUTDOWN_MS = 5e3;
-/** The abort reason a child's own deadline carries. */
-const CHILD_DEADLINE_REASON = "child deadline exceeded";
-/** The abort reason the root's budget deadline cascades to every node. */
-const ROOT_DEADLINE_REASON = "root budget deadline exceeded";
-/** Whether an abort reason is a deadline: the child's own or the root budget's. */
-function isDeadlineAbortReason(reason) {
-	return reason === "child deadline exceeded" || reason === "root budget deadline exceeded";
-}
-const TEARDOWN_ACKNOWLEDGEMENT_MS = 250;
-/** Arm a finite wall-clock deadline in safe chunks. Resource deadlines unref by default;
-* a standalone wait opts into keeping the process alive until it settles or is cancelled. */
-function armDeadlineTimer(delayMs, onDeadline, keepAlive = false) {
-	const deadlineAtMs = Date.now() + Math.max(0, delayMs);
-	if (!Number.isFinite(delayMs) || !Number.isSafeInteger(Math.ceil(deadlineAtMs))) throw new ValidationError$1("timer delay must produce a finite safe deadline");
-	let cleared = false;
-	let timer;
-	const arm = () => {
-		if (cleared) return;
-		const remainingMs = Math.max(0, deadlineAtMs - Date.now());
-		timer = setTimeout(() => {
-			if (cleared) return;
-			if (Date.now() >= deadlineAtMs) onDeadline();
-			else arm();
-		}, Math.min(remainingMs, MAX_TIMER_DELAY_MS));
-		if (!keepAlive && typeof timer.unref === "function") timer.unref();
-	};
-	arm();
-	return () => {
-		cleared = true;
-		if (timer !== void 0) clearTimeout(timer);
-	};
-}
-/**
-* Resolve a spawned child's duration into one absolute cutoff. An omitted child deadline inherits
-* the parent cutoff; an explicit child duration may shorten, but never extend, that cutoff.
-*/
-function boundedChildDeadlineAt(parentDeadlineAtMs, childDeadlineMs, nowMs) {
-	const parent = parentDeadlineAtMs > 0 ? parentDeadlineAtMs : void 0;
-	const child = childDeadlineMs === void 0 ? void 0 : nowMs + childDeadlineMs;
-	if (parent === void 0) return child;
-	if (child === void 0) return parent;
-	return Math.min(parent, child);
-}
-/** Invoke teardown once and bound how long the runtime waits for its acknowledgement. A hard
-* execution deadline always wins; without one, numeric grace gets a short acknowledgement
-* allowance and a brutal kill gets only that allowance. Explicit `infinity` remains unbounded
-* only when no execution deadline exists. The losing promise stays observed. `ask` issues the
-* request; a scope passes its per-child single-flight asker (see `singleFlightTeardown`). */
-async function teardownExecutor(executor, grace, deadlineAtMs, now, ask = (requested) => Promise.resolve(executor.teardown(requested))) {
-	const work = Promise.resolve(ask(grace));
-	const requestedWaitMs = grace === "infinity" ? void 0 : grace === "brutalKill" ? executor.teardownTimeoutMs ?? TEARDOWN_ACKNOWLEDGEMENT_MS : grace + TEARDOWN_ACKNOWLEDGEMENT_MS;
-	const deadlineWaitMs = deadlineAtMs === void 0 ? void 0 : Math.max(0, deadlineAtMs - now()) + TEARDOWN_ACKNOWLEDGEMENT_MS;
-	const waitMs = requestedWaitMs === void 0 ? deadlineWaitMs : deadlineWaitMs === void 0 ? requestedWaitMs : Math.min(requestedWaitMs, deadlineWaitMs);
-	let receipt;
-	if (waitMs === void 0) receipt = await work;
-	else if (waitMs <= 0) {
-		work.catch(() => void 0);
-		throw new ValidationError$1("executor teardown did not acknowledge before its deadline");
-	} else {
-		let clearTimer;
-		const timedOut = new Promise((_resolve, reject) => {
-			clearTimer = armDeadlineTimer(waitMs, () => reject(new ValidationError$1(`executor teardown did not acknowledge within ${waitMs}ms`)), true);
-		});
-		try {
-			receipt = await Promise.race([work, timedOut]);
-		} finally {
-			clearTimer?.();
-		}
-	}
-	if (!receipt.destroyed) throw new ValidationError$1(`executor teardown reported destroyed=false${receipt.detail ? `: ${receipt.detail}` : ""}`);
-}
-/**
-* The optional teardown surfaces a wrapping executor forwards, so wrapping never changes how a
-* child is released: the acknowledgement window a remote teardown needs, the release of a
-* retained execution at root settlement, and the environments an unconfirmed teardown names for
-* a sweeper. A wrapper that dropped `releaseRetained` left every retained child it wrapped
-* running after settlement. Each surface is present only when the inner executor implements it.
-*/
-function teardownSurfaces(inner) {
-	return {
-		...inner.teardownTimeoutMs === void 0 ? {} : { teardownTimeoutMs: inner.teardownTimeoutMs },
-		...inner.releaseRetained === void 0 ? {} : { releaseRetained: (signal) => inner.releaseRetained(signal) },
-		...inner.heldEnvironments === void 0 ? {} : { heldEnvironments: () => inner.heldEnvironments() }
-	};
-}
-/**
-* An asker that sends an executor at most one teardown at a time. While a request is still
-* running, every later ask returns that same request instead of sending another beside it.
-*
-* A settlement's own teardown has a short acknowledgement window, and a request that misses it
-* keeps running. Without this, the first settlement retry sent a second teardown next to the
-* first. An executor that does not deduplicate internally, such as one that re-issues its
-* cancels, then ran two teardowns at once. `onRequest` runs once for each request actually sent.
-*/
-function singleFlightTeardown(executor, onRequest) {
-	let inFlight;
-	return (grace) => {
-		if (inFlight !== void 0) return inFlight;
-		onRequest();
-		let request;
-		try {
-			request = Promise.resolve(executor.teardown(grace));
-		} catch (error) {
-			request = Promise.reject(error);
-		}
-		inFlight = request;
-		const settle = () => {
-			if (inFlight === request) inFlight = void 0;
-		};
-		request.then(settle, settle);
-		return request;
-	};
-}
-//#endregion
 //#region src/runtime/retained-run-binding.ts
 function exactSession(environment, controlRef) {
 	if (environment.id !== controlRef.environmentId || environment.provider !== controlRef.provider) throw new Error("provider reconstructed a different retained environment");
@@ -315,7 +198,7 @@ async function awaitAbortable$1(work, signal) {
 	if (signal === void 0) return await work;
 	if (signal.aborted) {
 		Promise.resolve(work).catch(() => void 0);
-		throw abortError$2(signal.reason);
+		throw abortError$1(signal.reason);
 	}
 	return await new Promise((resolve, reject) => {
 		let settled = false;
@@ -325,7 +208,7 @@ async function awaitAbortable$1(work, signal) {
 				if (settled) return;
 				settled = true;
 				cleanup();
-				reject(abortError$2(signal.reason));
+				reject(abortError$1(signal.reason));
 			});
 		};
 		signal.addEventListener("abort", onAbort, { once: true });
@@ -382,7 +265,7 @@ function isRecord$3(value) {
 function assertStableText(value, label) {
 	if (value.length === 0 || value.trim() !== value) throw new Error(`${label} must be non-empty and have no outer whitespace`);
 }
-function abortError$2(reason) {
+function abortError$1(reason) {
 	const error = new Error(reason instanceof Error ? reason.message : reason === void 0 ? "aborted" : String(reason));
 	error.name = "AbortError";
 	return error;
@@ -419,7 +302,7 @@ function isTerminalSessionStatus(status) {
 	return status !== null && sessionStatusIsTerminal[status];
 }
 function delay(ms, signal) {
-	if (signal?.aborted) return Promise.reject(abortError$2(signal.reason));
+	if (signal?.aborted) return Promise.reject(abortError$1(signal.reason));
 	return new Promise((resolveDelay, rejectDelay) => {
 		const clearTimer = armDeadlineTimer(ms, finish, true);
 		function finish() {
@@ -429,7 +312,7 @@ function delay(ms, signal) {
 		function onAbort() {
 			clearTimer();
 			signal?.removeEventListener("abort", onAbort);
-			rejectDelay(abortError$2(signal?.reason));
+			rejectDelay(abortError$1(signal?.reason));
 		}
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
@@ -654,477 +537,6 @@ function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region src/runtime/supervise/resources.ts
-/** Validate caller-owned names and units without assigning domain meaning to them. */
-function assertResources(resources, kind, label) {
-	if (resources === void 0) return;
-	if (resources === null || typeof resources !== "object" || Array.isArray(resources)) throw new Error(`${label} must be a resource map`);
-	for (const [name, resource] of Object.entries(resources)) {
-		if (!name.trim() || !resource || typeof resource !== "object" || typeof resource.unit !== "string" || !resource.unit.trim()) throw new Error(`${label}: resource names and units must be non-empty strings`);
-		const value = kind === "limit" ? "limit" in resource ? resource.limit : void 0 : "amount" in resource ? resource.amount : void 0;
-		if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${label}.${name}.${kind} must be a non-negative safe integer`);
-		if (kind === "amount" && (!("known" in resource) || typeof resource.known !== "boolean")) throw new Error(`${label}.${name}.known must be a boolean`);
-	}
-}
-/** Missing contributors are not usage claims; enforced omissions are marked before aggregation.
-* Overflow retains a safe lower bound and marks it unknown, preserving readable component receipts. */
-function addResourceSpend(...maps) {
-	const totals = /* @__PURE__ */ new Map();
-	for (const resources of maps) {
-		assertResources(resources, "amount", "resource spend");
-		for (const [name, resource] of Object.entries(resources ?? {})) {
-			const prior = totals.get(name);
-			if (prior && prior.unit !== resource.unit) throw new Error(`resource ${name}: unit mismatch`);
-			const amount = (prior?.amount ?? 0) + resource.amount;
-			totals.set(name, {
-				unit: resource.unit,
-				amount: Math.min(amount, Number.MAX_SAFE_INTEGER),
-				known: (prior?.known ?? true) && resource.known && Number.isSafeInteger(amount)
-			});
-		}
-	}
-	return totals.size ? { resources: Object.fromEntries(totals) } : {};
-}
-/** A terminal omission under an enforced ceiling is unknown, never measured zero. */
-function withBudgetResources(spend, budget, notStarted = false) {
-	const resources = new Map(Object.entries(addResourceSpend(spend.resources).resources ?? {}));
-	for (const [name, limit] of Object.entries(budget.resources ?? {})) {
-		const observed = resources.get(name);
-		if (observed && observed.unit !== limit.unit) throw new Error(`resource ${name}: unit mismatch`);
-		if (!observed) resources.set(name, {
-			unit: limit.unit,
-			amount: 0,
-			known: notStarted
-		});
-	}
-	return resources.size ? {
-		...spend,
-		resources: Object.fromEntries(resources)
-	} : spend;
-}
-/** Stream increments and a terminal total describe the same work; never sum them twice. */
-function resourceTelemetry(streamed, terminal) {
-	const resources = new Map(Object.entries(addResourceSpend(terminal.resources).resources ?? {}));
-	for (const [name, value] of Object.entries(streamed.resources ?? {})) {
-		const other = resources.get(name);
-		if (other && other.unit !== value.unit) throw new Error(`resource ${name}: unit mismatch`);
-		resources.set(name, {
-			...value,
-			amount: Math.max(value.amount, other?.amount ?? 0),
-			known: value.known && (other?.known ?? true) && (other === void 0 || other.amount === value.amount)
-		});
-	}
-	return addResourceSpend(Object.fromEntries(resources));
-}
-//#endregion
-//#region src/runtime/util.ts
-/**
-* Best-effort sandbox delete. Skips instances without a `delete` (test fakes);
-* swallows errors (the platform reaps on expiry). Returns `false` when delete
-* threw, `true` otherwise, so callers can surface a leak if they choose.
-*/
-async function deleteBoxSafe(box) {
-	if (!box || typeof box.delete !== "function") return true;
-	try {
-		await box.delete();
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */
-function randomSuffix(len = 8) {
-	return Math.random().toString(36).slice(2, 2 + len);
-}
-/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */
-function randomUuid() {
-	return crypto.randomUUID();
-}
-/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */
-function abortError$1() {
-	const err = /* @__PURE__ */ new Error("aborted");
-	err.name = "AbortError";
-	return err;
-}
-/** Throw an AbortError. */
-function throwAbort() {
-	throw abortError$1();
-}
-/** Throw if the signal is already aborted; otherwise no-op. */
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw abortError$1();
-}
-/** True for any error whose `name` is `AbortError` (the cross-kernel abort contract). */
-function isAbortError$2(err) {
-	return err instanceof Error && err.name === "AbortError";
-}
-/**
-* Sleep that resolves early on abort and always clears its timer so it never
-* keeps the event loop alive. Resolves (does not reject) on abort — callers
-* re-check the signal explicitly after the sleep.
-*/
-function sleep(ms, signal, keepAlive = true) {
-	if (signal?.aborted) return Promise.resolve();
-	return new Promise((resolve) => {
-		const done = () => {
-			clearTimer();
-			signal?.removeEventListener("abort", done);
-			resolve();
-		};
-		const clearTimer = armDeadlineTimer(ms, done, keepAlive);
-		signal?.addEventListener("abort", done, { once: true });
-	});
-}
-/**
-* Race a promise against a timeout. Resolves with the value if it settles in
-* time, otherwise resolves with `undefined`. Always clears the timer.
-*/
-function withTimeout(promise, ms) {
-	return new Promise((resolve) => {
-		const clearTimer = armDeadlineTimer(ms, () => resolve(void 0), true);
-		promise.then((value) => {
-			clearTimer();
-			resolve(value);
-		}, () => {
-			clearTimer();
-			resolve(void 0);
-		});
-	});
-}
-/**
-* `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).
-* Strings pass through unstringified so a preview of a string output is the
-* string itself, not a quoted re-encoding.
-*/
-function stringifySafe(value, opts = {}) {
-	let s;
-	try {
-		if (typeof value === "string") s = value;
-		else s = (opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)) ?? String(value);
-	} catch {
-		s = String(value);
-	}
-	if (opts.max !== void 0 && s.length > opts.max) return `${s.slice(0, opts.max)}…`;
-	return s;
-}
-/** A fresh zero token-usage accumulator. */
-function zeroTokenUsage() {
-	return {
-		input: 0,
-		output: 0
-	};
-}
-/**
-* Sum the catalog-priced part of a dollar total across spends, as a field to spread.
-*
-* Returns nothing when no input carried one. A fold of pure provider receipts must not gain a
-* `usdEstimated: 0`, which would read as "this runtime checked and priced none" on a path that
-* never prices at all.
-*/
-function usdEstimatedOf(...spends) {
-	let total = 0;
-	let priced = false;
-	for (const spend of spends) {
-		if (spend.usdEstimated === void 0) continue;
-		priced = true;
-		total += spend.usdEstimated;
-	}
-	return priced ? { usdEstimated: total } : {};
-}
-/** A conserved spend with every channel at zero and no completeness claim on it. */
-function zeroSpend() {
-	return {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		usd: 0,
-		ms: 0
-	};
-}
-/**
-* The spend of work that HAPPENED and reported no usage receipt.
-*
-* Not the same value as {@link zeroSpend} even though both carry `{0,0}` tokens and `$0`. A bare
-* zero asserts a MEASUREMENT — "this ran and cost nothing" — and every consumer downstream reads it
-* that way: the pool keeps reporting `readout().tokensKnown === true`, the journal totals stay
-* clean, the OTEL span records a priced zero, and a caller's token-denominated ceiling can never
-* fire no matter how much the work really burned. A ceiling that cannot fire is worse than no
-* ceiling, because it reads as protection.
-*
-* `tokensKnown` is the marker the substrate already threads end to end for exactly this case
-* (`budget.ts`, `otel-spans.ts`, `spawn-journal.ts`, `supervisor.ts`): the work is recorded, the
-* zero is labelled a floor rather than a total, and every rollup that touches it reports its
-* balance as a ceiling rather than a measurement. Use this — never a bare zero — whenever a runtime
-* cannot see what its worker spent.
-*
-* The same rule applies to dollars. A dollar-capped run must refuse an executor whose billed spend
-* is unknowable; `budgetExempt` does not authorize Runtime to relabel unknown spend as a measured
-* zero. Callers that require dollar accounting must use a backend with a trusted billing receipt.
-*/
-function unmeteredSpend(ms) {
-	return {
-		iterations: 0,
-		tokens: zeroTokenUsage(),
-		tokensKnown: false,
-		usd: 0,
-		usdKnown: false,
-		ms
-	};
-}
-/** Copy a conserved spend without dropping a completeness marker or the catalog-priced part. */
-function cloneSpend(spend) {
-	return {
-		...addResourceSpend(spend.resources),
-		iterations: spend.iterations,
-		tokens: cloneTokenUsage(spend.tokens),
-		...spend.tokensKnown === false ? { tokensKnown: false } : {},
-		usd: spend.usd,
-		...spend.usdKnown === false ? { usdKnown: false } : {},
-		...spend.usdEstimated !== void 0 ? { usdEstimated: spend.usdEstimated } : {},
-		ms: spend.ms,
-		...boxMinutesOf(spend),
-		...spend.tokensProvenance === void 0 ? {} : { tokensProvenance: spend.tokensProvenance }
-	};
-}
-/**
-* Sum two conserved spends per channel. Tokens and dollars never fold into each other, an
-* incomplete input keeps the sum incomplete on that channel, and the catalog-priced part of the
-* dollar total is summed separately so `usd - usdEstimated` still names what a provider billed.
-*/
-function addSpend(a, b) {
-	const tokens = cloneTokenUsage(a.tokens);
-	addTokenUsage(tokens, b.tokens);
-	return {
-		...addResourceSpend(a.resources, b.resources),
-		iterations: a.iterations + b.iterations,
-		tokens,
-		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
-		usd: a.usd + b.usd,
-		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
-		...usdEstimatedOf(a, b),
-		ms: a.ms + b.ms,
-		...boxMinutesOf(a, b),
-		...tokensProvenanceOf(a, b)
-	};
-}
-/**
-* Fold the token-provenance channel across spends, as a field to spread.
-*
-* Returns nothing when no contributor stated one, because ABSENT already means "the executor's own
-* live stream", which is what every path reported before a harness store was readable. A
-* contributor that stated one and a contributor that did not therefore disagree, and the sum is
-* `'mixed'` — the honest answer for a tree whose spend came from two kinds of receipt.
-*/
-function tokensProvenanceOf(...spends) {
-	let folded;
-	let sawStated = false;
-	for (const spend of spends) {
-		const stated = spend.tokensProvenance ?? "stream-receipt";
-		if (spend.tokensProvenance !== void 0) sawStated = true;
-		folded = folded === void 0 || folded === stated ? stated : "mixed";
-	}
-	return !sawStated || folded === void 0 || folded === "stream-receipt" ? {} : { tokensProvenance: folded };
-}
-/**
-* Fold the platform box-time channel across spends, as a field to spread.
-*
-* Returns nothing when no input carried the channel, so a fold over router or cli-bridge work —
-* which runs no box at all — never gains a `boxMinutesProvenance: 'uncaptured'` that would claim
-* a box ran and went unmetered.
-*
-* Three rules, one per field:
-*  - `boxMinutes` sums the numbers that are present, and stays ABSENT when none is. A missing
-*    measurement never enters the sum as a zero.
-*  - `boxMinutesKnown` is sticky-false, like `tokensKnown`: one contributor that could not state
-*    its box time makes the whole sum a floor.
-*  - `boxMinutesProvenance` degrades. `'observed'` survives only when every contributor that
-*    carried a number was observed; one derived number makes the sum `'estimated'`; no number at
-*    all is `'uncaptured'`.
-*/
-function boxMinutesOf(...spends) {
-	const present = spends.filter((spend) => spend.boxMinutesProvenance !== void 0);
-	if (present.length === 0) return {};
-	let minutes = 0;
-	let sawNumber = false;
-	let known = true;
-	let observedOnly = true;
-	for (const spend of present) {
-		if (typeof spend.boxMinutes === "number" && Number.isFinite(spend.boxMinutes)) {
-			minutes += spend.boxMinutes;
-			sawNumber = true;
-			if (spend.boxMinutesProvenance !== "observed") observedOnly = false;
-		}
-		if (spend.boxMinutesKnown !== true) known = false;
-	}
-	return {
-		...sawNumber ? { boxMinutes: roundBoxMinutes(minutes) } : {},
-		boxMinutesKnown: known,
-		boxMinutesProvenance: sawNumber ? observedOnly ? "observed" : "estimated" : "uncaptured"
-	};
-}
-/**
-* Box minutes at four decimals — a tenth of a second.
-*
-* Fine enough that a box alive for two seconds reports `0.0333` instead of a zero that would read
-* as a measured free box, and coarse enough that summing floats does not print
-* `1.5000000000000002`.
-*/
-function roundBoxMinutes(minutes) {
-	return Number(minutes.toFixed(4));
-}
-/** Copy a token subtotal without dropping optional provider cache telemetry. */
-function cloneTokenUsage(usage) {
-	const cacheBreakdownUnknown = usage.cacheBreakdownKnown === false || usage.input > 0 && !hasClassifiedCacheBreakdown(usage);
-	return {
-		input: usage.input,
-		output: usage.output,
-		...usage.tokensKnown === false ? { tokensKnown: false } : {},
-		...usage.freshInput !== void 0 ? { freshInput: usage.freshInput } : {},
-		...usage.cacheRead !== void 0 ? { cacheRead: usage.cacheRead } : {},
-		...usage.cacheWrite !== void 0 ? { cacheWrite: usage.cacheWrite } : {},
-		...cacheBreakdownUnknown ? { cacheBreakdownKnown: false } : {}
-	};
-}
-/** True only when every positive prompt token has a consistent cache classification. */
-function hasCompleteCacheBreakdown(usage) {
-	if (usage.cacheBreakdownKnown === false) return false;
-	return hasClassifiedCacheBreakdown(usage);
-}
-function hasClassifiedCacheBreakdown(usage) {
-	if (usage.input === 0) return true;
-	if (usage.freshInput === void 0 || usage.cacheRead === void 0 || usage.cacheWrite === void 0) return false;
-	return usage.freshInput + usage.cacheRead + usage.cacheWrite === usage.input;
-}
-/**
-* The token charge for one observation: every token counted ONCE, at the moment it first enters
-* the context — `input − cacheRead + output`.
-*
-* `input` is a rolled-up prompt total that re-counts a cached prefix on every turn that reads it,
-* so charging `input` makes a 100K prefix read 40 times cost 4.1M for content authored once. A
-* cache read is content that was already charged when it was written, so it is the one class the
-* charge subtracts. Under a complete split the result is exactly `freshInput + cacheWrite`. No
-* price weight is involved: this counts work, and money is a separate channel.
-*
-* The subtraction form is what makes the charge ADDITIVE. `input` and `cacheRead` both accumulate
-* through `addTokenUsage`, so the charge on an aggregate equals the sum of the charges on the
-* records that built it — including an aggregate that mixes classified and unclassified turns,
-* where the unclassified remainder is charged in full and only the reported cache reads are
-* credited. A form that read `freshInput + cacheWrite` directly loses that: one unclassified turn
-* would drop the whole aggregate to `input + output` and over-charge every classified turn with it.
-*
-* The one arithmetic guarantee: a set of classes that does not FIT inside the prompt total it
-* partitions credits nothing, so the charge is never below `output` and a class that overflows its
-* own total buys no tokens. It is not a guarantee against a provider that reports a cache read it
-* never served — that provider can under-report `input` just as easily, and the token channel is an
-* accounting unit, not a trust boundary. Prompt tokens the provider left unclassified are charged
-* in full, so a spend with no readable split charges an upper bound on newly-presented work rather
-* than a measurement, and every caller that enforces a ceiling must report the difference
-* (`BudgetPool` does it through `readout().cacheBreakdownKnown`).
-*/
-function chargedTokens(usage) {
-	return usage.input - creditedCacheRead(usage) + usage.output;
-}
-/** `cacheRead` if the reported classes fit inside `input`, else nothing. */
-function creditedCacheRead(usage) {
-	const { cacheRead } = usage;
-	if (cacheRead === void 0) return 0;
-	return classifiedTotal(usage, cacheRead) > usage.input ? 0 : cacheRead;
-}
-function classifiedTotal(usage, cacheRead) {
-	return (usage.freshInput ?? 0) + cacheRead + (usage.cacheWrite ?? 0);
-}
-/**
-* Translate one provider prompt-cache report into the prompt token classes `addTokenUsage` folds
-* and `chargedTokens` credits.
-*
-* The input is the open `promptCache` record an `llm_call` carries, keyed by the `PromptCacheUsage`
-* vocabulary (`readTokens`, `writeTokens`). Providers report that vocabulary unevenly, and the
-* three outcomes are different facts that must not collapse into one another:
-*
-*  - **Nothing reported** — no classes and no marker. The caller's own unknown handling decides,
-*    because a provider that says nothing about caching has not said the split is unknowable.
-*  - **Read and write both reported, and fitting inside `input`** — a complete partition, so
-*    `freshInput` is the remainder and the split is known.
-*  - **One counter reported, or classes that overflow `input`** — the counters that ARE measured
-*    pass through and `cacheBreakdownKnown` is false. A read with no write counter (OpenAI reports
-*    no write) still credits the read it measured, while declaring the rest unclassified so the
-*    charge stays a declared upper bound. An overflowing claim buys nothing: it cannot be a
-*    partition of a total it exceeds.
-*
-* A counter the provider did not report stays absent. A zero would claim the provider measured no
-* cache, which is a different fact from a provider that did not report.
-*/
-function promptCacheTokenClasses(input, promptCache) {
-	if (promptCache === void 0) return {};
-	const read = tokenCount(promptCache.readTokens);
-	const write = tokenCount(promptCache.writeTokens);
-	if (read === void 0 && write === void 0) return {};
-	if (input === void 0 || (read ?? 0) + (write ?? 0) > input) return { cacheBreakdownKnown: false };
-	if (read !== void 0 && write !== void 0) return {
-		freshInput: input - read - write,
-		cacheRead: read,
-		cacheWrite: write
-	};
-	return {
-		...read !== void 0 ? { cacheRead: read } : {},
-		...write !== void 0 ? { cacheWrite: write } : {},
-		cacheBreakdownKnown: false
-	};
-}
-function tokenCount(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
-}
-/**
-* Add the observed subtotal into `acc`; token and cache incompleteness are sticky.
-*
-* A delta whose classes do not FIT inside its own `input` contributes its prompt total and NO
-* classes. Folding them in would hide the overflow: the accumulator's larger `input` can absorb a
-* class total that overflowed the one delta that reported it, and `chargedTokens` would then credit
-* at the aggregate a cache read it refuses at the record. That is the one way the charge could come
-* out below the sum of the charges on the records that built it.
-*/
-function addTokenUsage(acc, delta) {
-	acc.input += delta.input ?? 0;
-	acc.output += delta.output ?? 0;
-	if (delta.tokensKnown === false) acc.tokensKnown = false;
-	const input = delta.input ?? 0;
-	const fits = classifiedTotal(delta, delta.cacheRead ?? 0) <= input;
-	if (fits) {
-		if (delta.freshInput !== void 0) acc.freshInput = (acc.freshInput ?? 0) + delta.freshInput;
-		if (delta.cacheRead !== void 0) acc.cacheRead = (acc.cacheRead ?? 0) + delta.cacheRead;
-		if (delta.cacheWrite !== void 0) acc.cacheWrite = (acc.cacheWrite ?? 0) + delta.cacheWrite;
-	}
-	const classified = fits && delta.freshInput !== void 0 && delta.cacheRead !== void 0 && delta.cacheWrite !== void 0 && delta.freshInput + delta.cacheRead + delta.cacheWrite === input;
-	if (delta.cacheBreakdownKnown === false || input > 0 && !classified) acc.cacheBreakdownKnown = false;
-}
-/**
-* Map `items` through `fn` with at most `limit` calls in flight at once,
-* preserving input order in the result. On the first `fn` rejection no NEW
-* items are picked up; already-in-flight calls are awaited, then the first
-* error is rethrown. `limit` is clamped to ≥ 1.
-*
-* Used where a burst of provisioning (e.g. forking N child boxes) must respect
-* the loop's concurrency bound instead of firing all N at once.
-*/
-async function mapWithConcurrency(items, limit, fn) {
-	const results = new Array(items.length);
-	let next = 0;
-	for await (const settled of runTaskQueue({
-		concurrency: Math.max(1, Math.min(Math.floor(limit), items.length)),
-		take: () => {
-			const index = next++;
-			return index < items.length ? {
-				id: String(index),
-				value: index
-			} : void 0;
-		},
-		execute: ({ value: index }) => fn(items[index], index)
-	})) {
-		if (settled.status === "rejected") throw settled.reason;
-		results[settled.task.value] = settled.value;
-	}
-	return results;
-}
-//#endregion
 //#region src/runtime/sandbox-events.ts
 const CANONICAL_STREAM_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"child-task",
@@ -1809,6 +1221,7 @@ function mapSandboxToolEvent(event, state) {
 		if (String(part.type ?? "") !== "tool") return [];
 		return projectToolPart(part, state, typeof event.id === "string" ? event.id : void 0);
 	}
+	if (CANONICAL_STREAM_EVENT_TYPES.has(type)) return [];
 	if (type.includes("tool")) {
 		const callId = pickString(data, [
 			"toolCallId",
@@ -2494,140 +1907,6 @@ function providerAttemptEvidence(model) {
 	});
 }
 //#endregion
-//#region src/durable/jsonl-file.ts
-/** Read a fixed file prefix one record at a time, never allocating the whole journal as a string.
-* A reader cannot chase concurrent appends forever. Missing files are empty only when requested;
-* corruption, short reads, and other I/O errors remain failures. Closing the iterator closes the fd. */
-async function* readCommittedJsonLines(path, options = {}) {
-	const fs = await import("node:fs/promises");
-	let handle;
-	try {
-		handle = await fs.open(path, "r");
-	} catch (error) {
-		if (options.allowMissing && isNoEntError(error)) return;
-		throw error;
-	}
-	try {
-		const { size } = await handle.stat();
-		if (size === 0) return;
-		const { StringDecoder } = await import("node:string_decoder");
-		const decoder = new StringDecoder("utf8");
-		const stream = handle.createReadStream({
-			autoClose: false,
-			end: size - 1
-		});
-		const fragments = [];
-		let lineNumber = 1;
-		try {
-			for await (const chunk of stream) {
-				options.onBytes?.(chunk);
-				const text = decoder.write(chunk);
-				let start = 0;
-				let end = text.indexOf("\n", start);
-				while (end !== -1) {
-					fragments.push(text.slice(start, end));
-					const record = parseRecord(fragments.join(""), path, lineNumber++, true);
-					fragments.length = 0;
-					if (record !== void 0) yield record.value;
-					start = end + 1;
-					end = text.indexOf("\n", start);
-				}
-				if (start < text.length) fragments.push(text.slice(start));
-			}
-			if (stream.bytesRead !== size) throw new Error(`${path}: journal changed while reading its committed prefix`);
-			fragments.push(decoder.end());
-			const record = parseRecord(fragments.join(""), path, lineNumber, false);
-			if (record !== void 0) yield record.value;
-		} finally {
-			stream.destroy();
-		}
-	} finally {
-		await handle.close();
-	}
-}
-/** An invalid unterminated tail may be a torn write; other parse failures are not evidence of one. */
-function parseRecord(line, source, lineNumber, terminated) {
-	if (line.length === 0) return void 0;
-	try {
-		return { value: JSON.parse(line) };
-	} catch (cause) {
-		if (!(cause instanceof SyntaxError)) throw cause;
-		if (!terminated) return void 0;
-		throw new Error(`${source}: malformed JSONL record at line ${lineNumber}`, { cause });
-	}
-}
-/** FileHandle.write may legally make a short write. Loop until every byte is appended. */
-async function writeAllBytes(handle, value) {
-	const bytes = typeof value === "string" ? Buffer.from(value) : Buffer.from(value);
-	let offset = 0;
-	while (offset < bytes.byteLength) {
-		const { bytesWritten } = await handle.write(bytes, offset, bytes.byteLength - offset, null);
-		if (bytesWritten <= 0) throw new Error(`append-only file write made no progress at byte ${offset}`);
-		offset += bytesWritten;
-	}
-}
-/** Prepare the tail under the journal owner's existing single-writer discipline.
-* Healthy appends read one byte, regardless of history size. Only recovery scans backward,
-* retaining a valid unterminated value or truncating an uncommitted torn tail. */
-async function prepareJsonlAppend(path) {
-	const fs = await import("node:fs/promises");
-	let handle;
-	try {
-		handle = await fs.open(path, "r+");
-	} catch (error) {
-		if (isNoEntError(error)) return false;
-		throw error;
-	}
-	try {
-		const size = (await handle.stat()).size;
-		if (size === 0) return false;
-		const lastByte = Buffer.allocUnsafe(1);
-		await readAt(handle, lastByte, size - 1);
-		if (lastByte[0] === 10) return false;
-		const chunks = [];
-		let end = size;
-		let tailStart = 0;
-		while (end > 0) {
-			const start = Math.max(0, end - 65536);
-			const chunk = Buffer.allocUnsafe(end - start);
-			await readAt(handle, chunk, start);
-			const newline = chunk.lastIndexOf(10);
-			chunks.push(chunk.subarray(newline + 1));
-			if (newline >= 0) {
-				tailStart = start + newline + 1;
-				break;
-			}
-			end = start;
-		}
-		const tail = Buffer.concat(chunks.reverse()).toString("utf8");
-		try {
-			JSON.parse(tail);
-			return true;
-		} catch (error) {
-			if (!(error instanceof SyntaxError)) throw error;
-			await handle.truncate(tailStart);
-			await handle.sync();
-			return false;
-		}
-	} finally {
-		await handle.close();
-	}
-}
-/** A short read is legal; an unexpected EOF means the owner's snapshot changed. */
-async function readAt(handle, buffer, position) {
-	let offset = 0;
-	while (offset < buffer.length) {
-		const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
-		if (bytesRead === 0) throw new Error("journal changed while preparing its append tail");
-		offset += bytesRead;
-	}
-}
-/** True for a filesystem error meaning "the file is not there yet" — the one condition an
-*  append-only reader treats as an empty log rather than a fault. */
-function isNoEntError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-//#endregion
 //#region src/agent/profile-materialization.ts
 const KNOWN_AXIS_SET = new Set(AGENT_PROFILE_MATERIALIZATION_AXES);
 /**
@@ -7313,6 +6592,49 @@ function normalizeWorkerSlotBound(value) {
 	if (!Number.isSafeInteger(value)) throw new ValidationError$1(`workerSlots must be a positive safe integer, or 0 or less for no bound, got ${String(value)}`);
 	return value;
 }
+const checkpointSlotKeys = /* @__PURE__ */ new WeakMap();
+function checkpointSlots(port) {
+	let key = checkpointSlotKeys.get(port);
+	if (key === void 0) {
+		key = Object.freeze({ maxConcurrentCaptures: port.maxConcurrentCaptures });
+		checkpointSlotKeys.set(port, key);
+	}
+	return key;
+}
+/**
+* Capture a checkpoint through the port on its own queue and bound, then verify that the store
+* holds every file of the returned tree and, when the checkpoint took a marker, that the tree
+* holds the marker's exact bytes, which proves it read this checkpoint and no other state.
+*/
+async function captureProviderCheckpointWorkspace(port, context, marker) {
+	assertProviderWorkspaceRetentionPort(port, "provider workspace retention");
+	const capture = port.captureCheckpoint;
+	if (capture === void 0) throw new ValidationError$1("provider workspace retention: the port has no captureCheckpoint");
+	const controller = new AbortController();
+	const clearDeadline = armDeadlineTimer(port.timeoutMs, () => controller.abort(/* @__PURE__ */ new Error(`checkpoint capture timed out after ${port.timeoutMs}ms`)), true);
+	try {
+		return await runAbortable(() => withCaptureSlot(checkpointSlots(port), controller.signal, async () => {
+			const tree = detachedSnapshot(await capture.call(port, {
+				...context,
+				signal: controller.signal
+			}), "checkpoint capture tree");
+			if (tree?.kind !== "agent-candidate-workspace-tree") throw new Error("checkpoint capture returned no workspace tree");
+			const material = await verifyAgentCandidateWorkspaceTree(tree, port.artifacts, {
+				...port.limits === void 0 ? {} : { limits: port.limits },
+				signal: controller.signal
+			});
+			if (material.files.length !== tree.files) throw new Error("checkpoint capture tree misstates its file count");
+			if (marker !== void 0) {
+				const bytes = Buffer.from(marker.content, "utf8");
+				const held = material.files.find((file) => file.path === marker.path);
+				if (held === void 0 || held.byteLength !== bytes.byteLength || held.sha256 !== `sha256:${createHash("sha256").update(bytes).digest("hex")}`) throw new Error(`checkpoint capture does not hold the checkpoint's marker ${marker.path}`);
+			}
+			return tree;
+		}), controller.signal, `checkpoint capture timed out after ${port.timeoutMs}ms`);
+	} finally {
+		clearDeadline();
+	}
+}
 /** Validate the executable retention port at the create boundary. */
 function assertProviderWorkspaceRetentionPort(port, context) {
 	if (!Number.isSafeInteger(port.timeoutMs) || port.timeoutMs <= 0) throw new ValidationError$1(`${context}: workspaceRetention.timeoutMs must be a positive safe integer`);
@@ -7320,6 +6642,7 @@ function assertProviderWorkspaceRetentionPort(port, context) {
 	if (port.artifacts === null || typeof port.artifacts?.read !== "function") throw new ValidationError$1(`${context}: workspaceRetention.artifacts.read is required`);
 	if (typeof port.capture !== "function") throw new ValidationError$1(`${context}: workspaceRetention.capture is required`);
 	if (port.captureNative !== void 0 && typeof port.captureNative !== "function") throw new ValidationError$1(`${context}: workspaceRetention.captureNative must be a function`);
+	if (port.captureCheckpoint !== void 0 && typeof port.captureCheckpoint !== "function") throw new ValidationError$1(`${context}: workspaceRetention.captureCheckpoint must be a function`);
 	for (const key of ["nativeIntervalMs", "nativeTimeoutMs"]) {
 		const value = port[key];
 		if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) throw new ValidationError$1(`${context}: workspaceRetention.${key} must be a positive safe integer`);
@@ -7335,6 +6658,7 @@ function nativeSlots(port) {
 	}
 	return key;
 }
+const capturesInFlight = /* @__PURE__ */ new WeakMap();
 async function withCaptureSlot(port, signal, capture) {
 	if (port.maxConcurrentCaptures === void 0) return capture();
 	let group = captureGroups.get(port);
@@ -7351,13 +6675,56 @@ async function withCaptureSlot(port, signal, capture) {
 		permit.release();
 	}
 }
-/**
-* Capture, require durable refs, and verify every returned manifest/archive byte.
-* `native` calls {@link ProviderWorkspaceRetentionPort.captureNative} under its own queue and
-* bound, and judges coverage by the sessions alone.
-*/
-async function captureProviderWorkspaceSnapshot(port, context, scope = "environment") {
-	assertProviderWorkspaceRetentionPort(port, "provider workspace retention");
+/** Count one capture of `port` in flight until `work` settles, and say how many were ahead. */
+function trackCapture(port, work) {
+	const ahead = capturesInFlight.get(port) ?? 0;
+	capturesInFlight.set(port, ahead + 1);
+	return work(ahead).finally(() => {
+		capturesInFlight.set(port, Math.max(0, (capturesInFlight.get(port) ?? 1) - 1));
+	});
+}
+/**
+* Capture, require durable refs, and verify every returned manifest/archive byte.
+* `native` calls {@link ProviderWorkspaceRetentionPort.captureNative} under its own queue and
+* bound, and judges coverage by the sessions alone. `onTiming` receives the queue wait and the
+* capture time of a workspace capture once it settles, whether it succeeded or failed.
+*/
+async function captureProviderWorkspaceSnapshot(port, context, scope = "environment", onTiming) {
+	assertProviderWorkspaceRetentionPort(port, "provider workspace retention");
+	if (scope === "native" || onTiming === void 0) return await captureWithinSlot(port, context, scope);
+	return await trackCapture(port, async (ahead) => {
+		const requestedAt = Date.now();
+		let grantedAt;
+		const report = (timing) => {
+			const settledAt = Date.now();
+			try {
+				onTiming({
+					ahead,
+					queuedMs: (grantedAt ?? settledAt) - requestedAt,
+					...grantedAt === void 0 ? {} : { captureMs: settledAt - grantedAt },
+					...timing
+				});
+			} catch {}
+		};
+		try {
+			const captured = await captureWithinSlot(port, context, scope, () => {
+				grantedAt = Date.now();
+			});
+			report({
+				outcome: "captured",
+				archiveBytes: captured.snapshot.archive.byteLength
+			});
+			return captured;
+		} catch (error) {
+			report({
+				outcome: "failed",
+				error: (error instanceof Error ? error.message : String(error)).slice(0, 1e3)
+			});
+			throw error;
+		}
+	});
+}
+async function captureWithinSlot(port, context, scope, onGranted) {
 	const native = scope === "native";
 	if (native && port.captureNative === void 0) throw new ValidationError$1("provider workspace retention: the port has no captureNative");
 	const timeoutMs = native ? port.nativeTimeoutMs ?? 12e4 : port.timeoutMs;
@@ -7367,6 +6734,7 @@ async function captureProviderWorkspaceSnapshot(port, context, scope = "environm
 	const clearDeadline = armDeadlineTimer(timeoutMs, () => controller.abort(/* @__PURE__ */ new Error(`provider workspace retention timed out after ${timeoutMs}ms`)), true);
 	try {
 		return await runAbortable(() => withCaptureSlot(native ? nativeSlots(port) : port, controller.signal, async () => {
+			onGranted?.();
 			const input = {
 				...context,
 				...controlRef === void 0 ? {} : { controlRef: Object.freeze({ ...controlRef }) },
@@ -7539,7 +6907,7 @@ async function environmentGone(provider, environmentId, signal) {
 }
 /** Create one environment while retaining ownership if cancellation wins the race. */
 async function createInteractiveEnvironment(create, signal) {
-	if (signal?.aborted) throw abortError$2(signal.reason);
+	if (signal?.aborted) throw abortError$1(signal.reason);
 	const creation = Promise.resolve().then(create);
 	if (signal === void 0) return creation;
 	return new Promise((resolve, reject) => {
@@ -7550,7 +6918,7 @@ async function createInteractiveEnvironment(create, signal) {
 			owner = "runtime";
 			removeAbortListener();
 			disposeInteractiveEnvironment(creation, signal.reason);
-			reject(abortError$2(signal.reason));
+			reject(abortError$1(signal.reason));
 		};
 		signal.addEventListener("abort", onAbort, { once: true });
 		creation.then((environment) => {
@@ -7570,7 +6938,7 @@ async function createInteractiveEnvironment(create, signal) {
 async function startInteractiveProcess(environment, start, signal) {
 	if (signal?.aborted) {
 		disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
-		throw abortError$2(signal.reason);
+		throw abortError$1(signal.reason);
 	}
 	const pending = Promise.resolve().then(start);
 	if (signal === void 0) return pending;
@@ -7582,7 +6950,7 @@ async function startInteractiveProcess(environment, start, signal) {
 			owner = "runtime";
 			removeAbortListener();
 			disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
-			reject(abortError$2(signal.reason));
+			reject(abortError$1(signal.reason));
 		};
 		signal.addEventListener("abort", onAbort, { once: true });
 		pending.then((result) => {
@@ -7717,7 +7085,7 @@ async function* retainedRunEvents(session, controlRef, options, now) {
 			try {
 				Promise.resolve(iterator.return?.()).catch(() => void 0);
 			} catch {}
-			throw abortError$2(options.signal.reason);
+			throw abortError$1(options.signal.reason);
 		}
 		if (error instanceof RetainedRunProviderContractError) throw error;
 		const fromProvider = error instanceof Error && !runtimeChecks.has(error);
@@ -7768,13 +7136,13 @@ function createRetainedRunHandle(environment, session, initialControlRef, capabi
 		}
 	};
 	const snapshot = async (reason, signal) => {
-		if (signal?.aborted) throw abortError$2(signal.reason);
+		if (signal?.aborted) throw abortError$1(signal.reason);
 		synchronizeActiveControlRef();
 		let status;
 		try {
 			status = await awaitAbortable$1(Promise.resolve().then(() => session.status({ signal })), signal);
 		} catch {
-			if (signal?.aborted) throw abortError$2(signal.reason);
+			if (signal?.aborted) throw abortError$1(signal.reason);
 			status = "unknown";
 		}
 		synchronizeActiveControlRef();
@@ -8001,7 +7369,7 @@ function createRetainedRunHandle(environment, session, initialControlRef, capabi
 			synchronizeActiveControlRef();
 			assertStableText(options.operationId, "retained cancellation operation id");
 			if (options.reason !== void 0) assertStableText(options.reason, "retained cancellation reason");
-			if (options.signal?.aborted) throw abortError$2(options.signal.reason);
+			if (options.signal?.aborted) throw abortError$1(options.signal.reason);
 			if (!hasDurableCancel(session)) throw new Error(`provider "${activeControlRef.provider}" does not expose durable cancellation operations`);
 			const request = cancellationRequest(activeControlRef, options.operationId, options.reason);
 			let effect = "unknown";
@@ -8366,6 +7734,7 @@ async function recoverRetainedRun(options) {
 		if (options.admission.provider !== options.provider.name) throw new Error("retained run intent belongs to another provider");
 		return {
 			outcome: "recovered",
+			via: "resumed",
 			handle: await startRetainedRun({
 				provider: options.provider,
 				...options.replay,
@@ -8406,6 +7775,7 @@ async function recoverRetainedRun(options) {
 	const exact = exactSession(environment, controlRef);
 	return {
 		outcome: "recovered",
+		via: "reattached",
 		handle: createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now)
 	};
 }
@@ -8652,6 +8022,119 @@ function describeRetainedNativeStops(stops) {
 	}).join("; ");
 }
 //#endregion
+//#region src/runtime/supervise/executor-seams.ts
+function assertExactConfigKeys(value, allowed, context) {
+	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+	if (unknown.length > 0) throw new ValidationError$1(`${context}: unknown fields ${unknown.sort().join(", ")}; execution behavior belongs in AgentProfile`);
+}
+/** Narrow a named seam off the `ExecutorContext`, failing loud when absent — no
+*  silent default for a required external-boundary seam. */
+function readSeam(ctx, key, who) {
+	const seam = ctx.seams[key];
+	if (seam === void 0 || seam === null) throw new ValidationError$1(`${who} executor: missing required seam "${key}" on ExecutorContext`);
+	return seam;
+}
+function readOptionalAbortSignal(ctx, key, who) {
+	const value = ctx.seams[key];
+	if (value === void 0) return void 0;
+	if (value === null || typeof value !== "object" || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function") throw new ValidationError$1(`${who} executor: seam "${key}" must be an AbortSignal`);
+	return value;
+}
+/** Narrow the Runtime-owned MCP attachment seam. Absent means the run mounts nothing; a present
+*  value must be a named map of MCP servers, never an empty one that would silently mount nothing. */
+function readOptionalMcpAttachments(ctx, key, who) {
+	const value = ctx.seams[key];
+	if (value === void 0) return void 0;
+	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : void 0;
+	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError$1(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
+	return value;
+}
+//#endregion
+//#region src/runtime/supervise/bridge-config.ts
+const bridgeSeamKey = "bridge";
+/** Internal control seam used by Runtime-owned external supervisors. A completion request stops
+* the next bridge turn; it must not abort the paid request that is already streaming. */
+const bridgeStopSignalKey = "__bridge_stop_signal";
+/** Internal attachment seam used by Runtime-owned external supervisors. The named MCP servers ride
+* beside the AgentProfile as `runtime_attachments`, so the bridge mounts them for the run and keeps
+* them out of its session profile binding. A rebound coordination port therefore cannot move the
+* authored profile digest that binds a durable session. */
+const bridgeRuntimeAttachmentsKey = "__bridge_runtime_attachments";
+const maxBridgeTimeoutMs = 2147483647;
+function isLoopbackBridgeHost(hostname) {
+	const host = hostname.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
+	if (host === "localhost" || host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
+	if (host === "::ffff:127.0.0.1") return true;
+	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/u.test(host);
+}
+function isLoopbackBridgeUrl(value) {
+	try {
+		const target = new URL(value);
+		return (target.protocol === "http:" || target.protocol === "https:") && isLoopbackBridgeHost(target.hostname);
+	} catch {
+		return false;
+	}
+}
+/** Validate and capture the non-serialisable credential service without reading its value. */
+function captureBridgeModelCredential(value, context) {
+	if (value === null || typeof value !== "object") throw new ValidationError$1(`${context}: modelCredential must be an object`);
+	assertExactConfigKeys(value, /* @__PURE__ */ new Set([
+		"baseUrlKey",
+		"key",
+		"provider"
+	]), `${context} modelCredential`);
+	if (typeof value.key !== "string" || value.key.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.key must be a non-empty string`);
+	if (typeof value.baseUrlKey !== "string" || value.baseUrlKey.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must be a non-empty string`);
+	if (value.baseUrlKey === value.key) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must differ from key`);
+	if (!value.provider || typeof value.provider.get !== "function") throw new ValidationError$1(`${context}: modelCredential.provider must implement get(name)`);
+	const captured = {
+		key: value.key,
+		baseUrlKey: value.baseUrlKey
+	};
+	Object.defineProperty(captured, "provider", {
+		configurable: false,
+		enumerable: false,
+		value: value.provider,
+		writable: false
+	});
+	return Object.freeze(captured);
+}
+function validateBridgeModelCredential(value, bridgeUrl, context) {
+	if (value === void 0) return void 0;
+	if (!isLoopbackBridgeUrl(bridgeUrl)) throw new ValidationError$1(`${context}: modelCredential is allowed only for a loopback bridge URL`);
+	return captureBridgeModelCredential(value, context);
+}
+function resolveProtectedModelBaseUrl(value, context) {
+	let target;
+	try {
+		target = new URL(value);
+	} catch {
+		throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an absolute HTTPS URL`);
+	}
+	if (target.protocol !== "https:" || target.username || target.password || target.search || target.hash) throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an HTTPS URL without credentials, query, or fragment`);
+	return target.toString().replace(/\/$/u, "");
+}
+/** Resolve only at the outbound boundary. Provider errors are redacted because they may contain
+*  the protected value; diagnostics identify key names, never values or provider errors. */
+async function resolveBridgeModelCredential(credential, context) {
+	if (credential === void 0) return void 0;
+	const resolveValue = async (key) => {
+		let value;
+		try {
+			value = await credential.provider.get(key);
+		} catch {
+			throw new ValidationError$1(`${context}: modelCredential provider failed for '${key}'`);
+		}
+		if (typeof value !== "string" || value.length === 0 || /[\r\n\0]/u.test(value)) throw new ValidationError$1(`${context}: modelCredential provider has no usable value for '${key}'`);
+		return value;
+	};
+	const [token, baseUrl] = await Promise.all([resolveValue(credential.key), resolveValue(credential.baseUrlKey)]);
+	return {
+		token,
+		baseUrl: resolveProtectedModelBaseUrl(baseUrl, context)
+	};
+}
+//#endregion
 //#region src/runtime/supervise/cost-estimate.ts
 /**
 * Pricing for work that arrived without a provider receipt.
@@ -9405,12 +8888,7 @@ function contentRef$1(prefix, value) {
 	} catch {
 		str = String(value);
 	}
-	let h = 2166136261;
-	for (let i = 0; i < str.length; i += 1) {
-		h ^= str.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return `${prefix}:${(h >>> 0).toString(16).padStart(8, "0")}`;
+	return `${prefix}:${fnv1a32Hex(str)}`;
 }
 //#endregion
 //#region src/runtime/supervise/trace-evidence.ts
@@ -9530,6 +9008,140 @@ function runtimeOwnedNestedDriverTreeRoot(owner, parentTreeRoot, driverNodeId) {
 	return nestedDriverTreeOwners.has(owner) ? nestedDriverTreeRoot(parentTreeRoot, driverNodeId) : void 0;
 }
 //#endregion
+//#region src/durable/jsonl-file.ts
+/** Read a fixed file prefix one record at a time, never allocating the whole journal as a string.
+* A reader cannot chase concurrent appends forever. Missing files are empty only when requested;
+* corruption, short reads, and other I/O errors remain failures. Closing the iterator closes the fd. */
+async function* readCommittedJsonLines(path, options = {}) {
+	const fs = await import("node:fs/promises");
+	let handle;
+	try {
+		handle = await fs.open(path, "r");
+	} catch (error) {
+		if (options.allowMissing && isNoEntError(error)) return;
+		throw error;
+	}
+	try {
+		const { size } = await handle.stat();
+		if (size === 0) return;
+		const { StringDecoder } = await import("node:string_decoder");
+		const decoder = new StringDecoder("utf8");
+		const stream = handle.createReadStream({
+			autoClose: false,
+			end: size - 1
+		});
+		const fragments = [];
+		let lineNumber = 1;
+		try {
+			for await (const chunk of stream) {
+				options.onBytes?.(chunk);
+				const text = decoder.write(chunk);
+				let start = 0;
+				let end = text.indexOf("\n", start);
+				while (end !== -1) {
+					fragments.push(text.slice(start, end));
+					const record = parseRecord(fragments.join(""), path, lineNumber++, true);
+					fragments.length = 0;
+					if (record !== void 0) yield record.value;
+					start = end + 1;
+					end = text.indexOf("\n", start);
+				}
+				if (start < text.length) fragments.push(text.slice(start));
+			}
+			if (stream.bytesRead !== size) throw new Error(`${path}: journal changed while reading its committed prefix`);
+			fragments.push(decoder.end());
+			const record = parseRecord(fragments.join(""), path, lineNumber, false);
+			if (record !== void 0) yield record.value;
+		} finally {
+			stream.destroy();
+		}
+	} finally {
+		await handle.close();
+	}
+}
+/** An invalid unterminated tail may be a torn write; other parse failures are not evidence of one. */
+function parseRecord(line, source, lineNumber, terminated) {
+	if (line.length === 0) return void 0;
+	try {
+		return { value: JSON.parse(line) };
+	} catch (cause) {
+		if (!(cause instanceof SyntaxError)) throw cause;
+		if (!terminated) return void 0;
+		throw new Error(`${source}: malformed JSONL record at line ${lineNumber}`, { cause });
+	}
+}
+/** FileHandle.write may legally make a short write. Loop until every byte is appended. */
+async function writeAllBytes(handle, value) {
+	const bytes = typeof value === "string" ? Buffer.from(value) : Buffer.from(value);
+	let offset = 0;
+	while (offset < bytes.byteLength) {
+		const { bytesWritten } = await handle.write(bytes, offset, bytes.byteLength - offset, null);
+		if (bytesWritten <= 0) throw new Error(`append-only file write made no progress at byte ${offset}`);
+		offset += bytesWritten;
+	}
+}
+/** Prepare the tail under the journal owner's existing single-writer discipline.
+* Healthy appends read one byte, regardless of history size. Only recovery scans backward,
+* retaining a valid unterminated value or truncating an uncommitted torn tail. */
+async function prepareJsonlAppend(path) {
+	const fs = await import("node:fs/promises");
+	let handle;
+	try {
+		handle = await fs.open(path, "r+");
+	} catch (error) {
+		if (isNoEntError(error)) return false;
+		throw error;
+	}
+	try {
+		const size = (await handle.stat()).size;
+		if (size === 0) return false;
+		const lastByte = Buffer.allocUnsafe(1);
+		await readAt(handle, lastByte, size - 1);
+		if (lastByte[0] === 10) return false;
+		const chunks = [];
+		let end = size;
+		let tailStart = 0;
+		while (end > 0) {
+			const start = Math.max(0, end - 65536);
+			const chunk = Buffer.allocUnsafe(end - start);
+			await readAt(handle, chunk, start);
+			const newline = chunk.lastIndexOf(10);
+			chunks.push(chunk.subarray(newline + 1));
+			if (newline >= 0) {
+				tailStart = start + newline + 1;
+				break;
+			}
+			end = start;
+		}
+		const tail = Buffer.concat(chunks.reverse()).toString("utf8");
+		try {
+			JSON.parse(tail);
+			return true;
+		} catch (error) {
+			if (!(error instanceof SyntaxError)) throw error;
+			await handle.truncate(tailStart);
+			await handle.sync();
+			return false;
+		}
+	} finally {
+		await handle.close();
+	}
+}
+/** A short read is legal; an unexpected EOF means the owner's snapshot changed. */
+async function readAt(handle, buffer, position) {
+	let offset = 0;
+	while (offset < buffer.length) {
+		const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, position + offset);
+		if (bytesRead === 0) throw new Error("journal changed while preparing its append tail");
+		offset += bytesRead;
+	}
+}
+/** True for a filesystem error meaning "the file is not there yet" — the one condition an
+*  append-only reader treats as an empty log rather than a fault. */
+function isNoEntError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+//#endregion
 //#region src/durable/spawn-journal.ts
 /**
 * Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a
@@ -10175,17 +9787,15 @@ var SpawnEventIndex = class {
 	}
 };
 /**
-* The records that CLOSE a node's cursor slot: a settlement, a cancellation, or a wait being
-* woken. The complement question to {@link outsideCursorNamespace}, and the one a resume needs —
+* The records that CLOSE a node's cursor slot: a settlement or a cancellation. The complement question to {@link outsideCursorNamespace}, and the one a resume needs —
 * a kind missing here leaves a finished node looking live, so its budget is never reclaimed and
 * its reservation is replayed as still in doubt.
 */
 function closesCursorSlot(ev) {
-	return ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken";
+	return ev.kind === "settled" || ev.kind === "cancelled";
 }
 const outsideKinds = /* @__PURE__ */ new Set([
 	"spawned",
-	"waiting",
 	"metered",
 	"materialized",
 	"execution-bound",
@@ -10202,8 +9812,12 @@ const outsideKinds = /* @__PURE__ */ new Set([
 	"environment-teardown",
 	"workspace-checkpoint-requested",
 	"workspace-checkpoint",
+	"workspace-checkpoint-fork-requested",
+	"workspace-checkpoint-fork-teardown",
+	"workspace-checkpoint-capture",
 	"workspace-checkpoint-cleanup",
 	"workspace-restored",
+	"workspace-capture",
 	"trace-unpropagated",
 	"paused",
 	"driver-attempt",
@@ -10242,7 +9856,7 @@ async function replaySpawnTree(journal, blobs, root) {
 	const materializations = /* @__PURE__ */ new Map();
 	const executionBindings = /* @__PURE__ */ new Map();
 	for (const ev of ordered) {
-		if (ev.kind === "spawned" || ev.kind === "waiting") labels.set(ev.id, ev.label);
+		if (ev.kind === "spawned") labels.set(ev.id, ev.label);
 		if (ev.kind === "spawned" && ev.assignmentId !== void 0) assignmentIds.set(ev.id, ev.assignmentId);
 		if (ev.kind === "spawned" && ev.identity !== void 0) identities.set(ev.id, copyFrozenIdentity(ev.identity));
 		if (ev.kind === "materialized") materializations.set(ev.id, ev.receipt);
@@ -10265,7 +9879,6 @@ async function replaySpawnTree(journal, blobs, root) {
 	const settled = [];
 	for (const ev of ordered) {
 		if (ev.kind === "spawned") continue;
-		if (ev.kind === "waiting") continue;
 		if (ev.kind === "metered") continue;
 		if (ev.kind === "progress") continue;
 		if (ev.kind === "reconciled") continue;
@@ -10278,47 +9891,18 @@ async function replaySpawnTree(journal, blobs, root) {
 		if (ev.kind === "environment-teardown") continue;
 		if (ev.kind === "workspace-checkpoint-requested") continue;
 		if (ev.kind === "workspace-checkpoint") continue;
+		if (ev.kind === "workspace-checkpoint-fork-requested") continue;
+		if (ev.kind === "workspace-checkpoint-fork-teardown") continue;
+		if (ev.kind === "workspace-checkpoint-capture") continue;
 		if (ev.kind === "workspace-checkpoint-cleanup") continue;
 		if (ev.kind === "workspace-restored") continue;
+		if (ev.kind === "workspace-capture") continue;
 		if (ev.kind === "trace-unpropagated") continue;
 		if (ev.kind === "paused") continue;
 		if (ev.kind === "driver-attempt") continue;
 		if (ev.kind === "node-inputs-resolved") continue;
 		if (ev.kind === "edge-verdict") continue;
 		if (ev.kind === "join-state") continue;
-		if (ev.kind === "woken") {
-			if (ev.by === "cancelled" || ev.outRef === void 0) {
-				settled.push({
-					kind: "down",
-					handle: handleFor(ev.id, "cancelled"),
-					reason: "wait cancelled",
-					infra: false,
-					trace: {
-						status: "unavailable",
-						reason: "not-an-executor"
-					},
-					...settlementTime(ev.at),
-					seq: ev.seq
-				});
-				continue;
-			}
-			const outcome = await blobs.get(ev.outRef);
-			if (outcome === void 0) throw new Error(`replaySpawnTree: blob store has no wait outcome for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`);
-			settled.push({
-				kind: "done",
-				handle: handleFor(ev.id, "done"),
-				out: outcome,
-				outRef: ev.outRef,
-				spent: zeroSpend(),
-				trace: {
-					status: "unavailable",
-					reason: "not-an-executor"
-				},
-				...settlementTime(ev.at),
-				seq: ev.seq
-			});
-			continue;
-		}
 		if (ev.kind === "cancelled") {
 			settled.push({
 				kind: "down",
@@ -10418,24 +10002,9 @@ function copyFrozenIdentity(identity) {
 function materializeTreeView(events) {
 	const nodes = /* @__PURE__ */ new Map();
 	let root;
-	const spawns = events.filter((ev) => ev.kind === "spawned" || ev.kind === "waiting").sort((a, b) => a.seq - b.seq);
+	const spawns = events.filter((ev) => ev.kind === "spawned").sort((a, b) => a.seq - b.seq);
 	const settlements = events.filter((ev) => insideCursorNamespace(ev)).sort((a, b) => a.seq - b.seq);
 	for (const ev of spawns) {
-		if (ev.kind === "waiting") {
-			nodes.set(ev.id, {
-				id: ev.id,
-				parent: ev.parent,
-				label: ev.label,
-				status: "waiting",
-				runtime: "wait",
-				budget: {
-					maxIterations: 0,
-					maxTokens: 0
-				},
-				spent: zeroSpend()
-			});
-			continue;
-		}
 		if (ev.parent === void 0 && root === void 0) root = ev.id;
 		nodes.set(ev.id, {
 			id: ev.id,
@@ -10463,16 +10032,6 @@ function materializeTreeView(events) {
 		if (ev.retainedPendingCause !== void 0) node.retainedPendingCause = ev.retainedPendingCause;
 		const settledAt = Date.parse(ev.at);
 		if (Number.isFinite(settledAt)) node.settledAt = settledAt;
-	} else if (ev.kind === "woken") {
-		const node = requireNode(nodes, ev.id);
-		node.status = ev.by === "cancelled" ? "cancelled" : "done";
-		node.outRef = ev.outRef;
-		node.trace = {
-			status: "unavailable",
-			reason: "not-an-executor"
-		};
-		const settledAt = Date.parse(ev.at);
-		if (Number.isFinite(settledAt)) node.settledAt = settledAt;
 	} else {
 		const node = requireNode(nodes, ev.id);
 		node.status = "cancelled";
@@ -10514,31 +10073,9 @@ function materializeTreeView(events) {
 	return {
 		root: root ?? snapshots[0]?.id ?? "",
 		nodes: snapshots,
-		inFlight: snapshots.filter((n) => n.status === "running" || n.status === "acquiring").length,
-		waiting: snapshots.filter((n) => n.status === "waiting").length
+		inFlight: snapshots.filter((n) => n.status === "running" || n.status === "acquiring").length
 	};
 }
-/**
-* The waits a journaled tree shows as ARMED but never woken — what a resumed run re-arms with the
-* ORIGINAL absolute deadline. Reading it from the journal (rather than from any live state) is
-* what makes "SIGKILL a waiting tree, a new process keeps waiting to the same instant" true.
-*/
-function pendingWaits(events) {
-	const woken = /* @__PURE__ */ new Set();
-	for (const ev of events) if (ev.kind === "woken") woken.add(ev.id);
-	const pending = [];
-	for (const ev of events) {
-		if (ev.kind !== "waiting" || woken.has(ev.id)) continue;
-		pending.push({
-			id: ev.id,
-			label: ev.label,
-			spec: ev.spec,
-			armedAt: ev.armedAt,
-			ordinal: ev.seq
-		});
-	}
-	return pending.sort((a, b) => a.ordinal - b.ordinal);
-}
 /** Copy a terminal record's overspend at the journal boundary; absent stays absent. */
 function budgetViolationOf(event) {
 	if (event.budgetViolation === void 0) return {};
@@ -10622,6 +10159,18 @@ function executorEvidenceWriter(args) {
 		});
 	};
 }
+/** @internal The journal writer for `onWorkspaceCapture`; `nextSequence` is the node's own. */
+function workspaceCaptureWriter(args) {
+	return async (capture) => {
+		await args.journal.appendEvent(args.rootId, {
+			kind: "workspace-capture",
+			id: args.nodeId,
+			...detachedSnapshot(capture, "workspace capture timing"),
+			seq: args.nextSequence(),
+			at: new Date(args.now()).toISOString()
+		});
+	};
+}
 function retainedExecutorContext(ctx) {
 	return ctx.seams[retainedExecutorSeamKey];
 }
@@ -11054,6 +10603,9 @@ function jitteredMs(ms, random) {
 const WORKSPACE_CHECKPOINT_MARKER_PATH = ".agent-runtime-checkpoint";
 /** Bound on one checkpoint: environment lookup, marker write, and the provider operation. */
 const WORKSPACE_CHECKPOINT_TIMEOUT_MS = 12e4;
+/** Bound on creating and reconstructing the fork a checkpoint's capture reads: a Sandbox box
+*  created from a snapshot (measured 2026-09-24: 19 s). The capture itself is bounded by its port. */
+const WORKSPACE_CHECKPOINT_FORK_TIMEOUT_MS = 10 * 6e4;
 /** Write the marker. False when the environment cannot take it, so no restore can be verified. */
 async function writeWorkspaceMarker(environment, marker, signal) {
 	if (typeof environment.write !== "function") return false;
@@ -11286,6 +10838,18 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	let pending = false;
 	let harnessTranscript = harnessTranscriptUnavailable("execution-never-started");
 	const retention = retainedExecutorContext(ctx);
+	const managerStop = readOptionalAbortSignal(ctx, bridgeStopSignalKey, "provider");
+	const cancelRetainedOnManagerStop = (handle) => {
+		if (managerStop === void 0) return;
+		const cancel = () => {
+			handle.cancel({
+				operationId: `manager-stop:${randomUUID()}`,
+				reason: String(managerStop.reason ?? "the manager stopped")
+			}).catch(() => void 0);
+		};
+		if (managerStop.aborted) cancel();
+		else managerStop.addEventListener("abort", cancel, { once: true });
+	};
 	let destroyed = false;
 	let workspaceEnvironmentId;
 	let workspaceSnapshot;
@@ -11378,7 +10942,19 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 				profile: createProfile,
 				...outcome === void 0 ? {} : { outcome }
 			};
-			workspaceCapturePromise = (nativeInFlight ?? Promise.resolve()).then(() => captureProviderWorkspaceSnapshot(workspaceRetention, captureContext)).then(({ snapshot, provenance, coverageComplete, incompleteReason }) => {
+			const reportTiming = retention?.onWorkspaceCapture;
+			let timing;
+			const capturedExecutionId = workspaceExecutionId;
+			workspaceCapturePromise = (nativeInFlight ?? Promise.resolve()).then(() => captureProviderWorkspaceSnapshot(workspaceRetention, captureContext, "environment", reportTiming === void 0 ? void 0 : (measured) => {
+				timing = measured;
+			})).finally(async () => {
+				if (timing === void 0 || reportTiming === void 0) return;
+				await reportTiming({
+					executionId: capturedExecutionId,
+					environmentId: next.id,
+					...timing
+				}).catch(() => void 0);
+			}).then(({ snapshot, provenance, coverageComplete, incompleteReason }) => {
 				workspaceSnapshot = snapshot;
 				workspaceProvenance = provenance;
 				workspaceCoverageComplete = coverageComplete ?? false;
@@ -11695,10 +11271,12 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 					...carried === void 0 ? {} : { carried },
 					executionStartedAt,
 					mayContinue: options.unavailablePause !== false && invocation.retention?.continueInvocation !== void 0,
+					managerStopped: () => managerStop?.aborted === true,
 					onRetained: (handle) => {
 						retained = handle;
 						workspaceControlRef = freezeControlRef(handle.controlRef);
 						providerSessionId = workspaceControlRef.sessionId;
+						cancelRetainedOnManagerStop(handle);
 					},
 					onPending: (value) => {
 						pending = value;
@@ -11978,6 +11556,19 @@ async function* streamProviderExecutor(args) {
 	let failure;
 	let failed = false;
 	let unavailable;
+	let finalCopyTaken = false;
+	const ownerTakesCapture = () => args.options.workspaceRetention?.captureNative !== void 0 && args.createProfile.harness !== void 0 && source.retained && args.retention?.preserveEnvironment === true && args.retention.onEndOfTurnWork !== void 0;
+	const handCaptureToOwner = (reported, captureOutcome, publish) => {
+		args.retention?.onEndOfTurnWork?.(args.captureWorkspace(environment, captureOutcome).then(async (snapshot) => {
+			if (publish) args.onPublishedSnapshot(snapshot);
+			if (snapshot === void 0) return;
+			await args.retention?.onEvidence?.({
+				...reported,
+				workspaceSnapshot: snapshot,
+				workspaceCapture: providerWorkspaceCaptureReceipt(args, environment, snapshot, turn.sessionId ?? null)
+			});
+		}, () => void 0));
+	};
 	let harnessStop;
 	const stopEndedHarness = () => {
 		if (settled !== void 0 || !linked.aborted) return Promise.resolve();
@@ -12058,14 +11649,17 @@ async function* streamProviderExecutor(args) {
 			box: environmentAsSandboxInstance(environment, { requireTerminalEvent: args.options.requireTerminalEvent ?? true }),
 			signal: linked
 		});
+		const deferCapture = ownerTakesCapture() && args.managerStopped();
 		let retainedWorkspace;
 		let workspaceCaptureFailure;
-		try {
-			retainedWorkspace = await args.captureWorkspace(environment, outcome);
-		} catch (error) {
-			workspaceCaptureFailure = `${errorText(error instanceof Error ? error.message : error)}; source environment preserved`;
+		if (!deferCapture) {
+			try {
+				retainedWorkspace = await args.captureWorkspace(environment, outcome);
+			} catch (error) {
+				workspaceCaptureFailure = `${errorText(error instanceof Error ? error.message : error)}; source environment preserved`;
+			}
+			args.onPublishedSnapshot(retainedWorkspace);
 		}
-		args.onPublishedSnapshot(retainedWorkspace);
 		const settledResult = {
 			...result,
 			...workspaceCaptureFailure === void 0 ? {} : { workspaceCaptureFailure },
@@ -12099,6 +11693,11 @@ async function* streamProviderExecutor(args) {
 		else if (retainedWorkspace !== void 0) await args.retention?.onEvidence?.(settledResult);
 		args.onPending(false);
 		args.onArtifact(settled);
+		if (deferCapture) {
+			await args.finishNativeMirror(environment, "settled");
+			finalCopyTaken = true;
+			handCaptureToOwner(settledResult, outcome, true);
+		}
 	} catch (error) {
 		failure = source.retained ? new RetainedExecutionPendingError(error) : error;
 		failed = true;
@@ -12112,7 +11711,14 @@ async function* streamProviderExecutor(args) {
 		await stopEndedHarness();
 		if (linked.aborted) await args.finishNativeMirror(environment, "failed");
 		args.onTranscriptSettled();
-		try {
+		if (ownerTakesCapture()) {
+			if (!linked.aborted) await args.finishNativeMirror(environment, "failed");
+			finalCopyTaken = true;
+			handCaptureToOwner({
+				...resultFromEvents(archive.events(), text),
+				outcome: failureOutcome
+			}, failureOutcome, false);
+		} else try {
 			const retainedWorkspace = await args.captureWorkspace(environment, failureOutcome);
 			if (retainedWorkspace !== void 0 && args.retention?.onEvidence !== void 0) await args.retention.onEvidence({
 				...resultFromEvents(archive.events(), text),
@@ -12127,7 +11733,7 @@ async function* streamProviderExecutor(args) {
 		if (args.options.workspaceRetention === void 0) args.onHarnessTranscript(await captureHarnessTranscript(environment, args.profile.harness, linked));
 	} finally {
 		await stopEndedHarness();
-		await args.finishNativeMirror(environment, failed ? "failed" : settled !== void 0 ? "settled" : "interrupted");
+		if (!finalCopyTaken) await args.finishNativeMirror(environment, failed ? "failed" : settled !== void 0 ? "settled" : "interrupted");
 		if ((!source.retained || settled !== void 0 && !failed) && !(source.retained && args.retention?.preserveEnvironment) && !(unavailable !== void 0 && !failed) && (args.options.destroyOnSettle ?? true)) {
 			const cleanup = await args.destroyEnvironment();
 			if (!cleanup.destroyed) {
@@ -13277,6 +12883,14 @@ async function runBrainLoop(opts) {
 				role: "assistant",
 				content: r.content
 			});
+			const next = maxTurns === 0 || turn < maxTurns ? await opts.hooks?.afterFinal?.(turn) : void 0;
+			if (next !== void 0) {
+				messages.push({
+					role: "user",
+					content: next
+				});
+				continue;
+			}
 			return {
 				final: lastText,
 				turns: turn,
@@ -14364,34 +13978,6 @@ function buildBackendOptions(profile, overrides) {
 	};
 }
 //#endregion
-//#region src/runtime/sandbox-capabilities.ts
-const probeCache = /* @__PURE__ */ new WeakMap();
-/**
-* Probe (and memoize per client) what the loop may rely on. A client without a
-* `criuStatus` method, or whose probe rejects, yields `canFork = false` — a
-* failed probe must never claim a capability the platform may not have. The
-* promise is cached so concurrent fanout branches share one round-trip.
-*
-* @experimental
-*/
-function probeSandboxCapabilities(client) {
-	const key = client;
-	const cached = probeCache.get(key);
-	if (cached) return cached;
-	const probe = resolveCapabilities(client);
-	probeCache.set(key, probe);
-	return probe;
-}
-async function resolveCapabilities(client) {
-	const criuStatus = client.criuStatus;
-	if (typeof criuStatus !== "function") return { canFork: false };
-	try {
-		return { canFork: (await criuStatus.call(client))?.available === true };
-	} catch {
-		return { canFork: false };
-	}
-}
-//#endregion
 //#region src/runtime/sandbox-lineage.ts
 const TEARDOWN_TIMEOUT_MS$1 = 15e3;
 const DEFAULT_FORK_CONCURRENCY = 4;
@@ -14457,13 +14043,11 @@ function promptEvents(streaming, box, prompt, sessionId, signal, promptOptions)
 	});
 }
 /**
-* Build a lineage bound to one client + its probed capabilities. The
-* capabilities are passed in (not re-probed) so the kernel probes once per run
-* and the lineage stays a pure function of "what this platform can do".
+* Build a lineage bound to one client. Branching is read from each box.
 *
 * @experimental
 */
-function createSandboxLineage(client, capabilities, options = {}) {
+function createSandboxLineage(client, options = {}) {
 	if (!client || typeof client.create !== "function") throw new ValidationError$1("createSandboxLineage: client.create is required");
 	const streaming = options.streaming ?? "sse";
 	const recordMount = options.recordMount ?? (() => {});
@@ -14553,30 +14137,10 @@ function createSandboxLineage(client, capabilities, options = {}) {
 					};
 				});
 			}
-			const checkpointId = capabilities.canFork ? await checkpointForFork(parent.box, signal) : void 0;
 			return mapWithConcurrency(prompts, forkConcurrency, async (prompt, i) => {
 				throwIfAborted(signal);
 				const spec = specs[i % specs.length];
 				if (!spec) throw new ValidationError$1("SandboxLineage.fork: no AgentRunSpec for branch");
-				if (checkpointId !== void 0) {
-					const box = await forkFromCheckpoint(parent.box, checkpointId, signal);
-					owned.push(box);
-					const inheritedProfile = profiles.get(parent.box) ?? spec.profile;
-					profiles.set(box, inheritedProfile);
-					options.onAcquire?.(box, inheritedProfile);
-					await spec.prepareBox?.(box, {
-						signal,
-						recordMount
-					});
-					const sessionId = mintSessionId();
-					return {
-						handle: {
-							box,
-							sessionId
-						},
-						events: promptEvents(streaming, box, prompt, sessionId, signal, optionsFor(i))
-					};
-				}
 				const box = await acquireFresh(spec, signal);
 				const sessionId = mintSessionId();
 				return {
@@ -14616,8 +14180,8 @@ function mintSessionId() {
 }
 /**
 * Branch a running parent through the current Sandbox SDK, in bounded waves.
-* `undefined` means the box exposes only the legacy checkpoint API (or no
-* branching API), so the caller may try the legacy capability-gated path.
+* `undefined` means the box exposes no branching API, so the caller starts
+* fresh boxes.
 */
 async function branchParent(box, count, concurrency, signal) {
 	const branch = box.branch;
@@ -14638,34 +14202,6 @@ async function branchParent(box, count, concurrency, signal) {
 	}
 }
 /**
-* Checkpoint the parent leaving it running, returning the checkpoint id to fork
-* from, or `undefined` when the box exposes no legacy `checkpoint` method or
-* the call produced no id. `undefined` makes the caller use fresh boxes — a
-* fork that cannot preserve context must not pretend to share it.
-*/
-async function checkpointForFork(box, signal) {
-	const checkpoint = box.checkpoint;
-	if (typeof checkpoint !== "function") return void 0;
-	if (signal.aborted) throwAbort();
-	const id = (await checkpoint.call(box, { leaveRunning: true }))?.checkpointId;
-	return typeof id === "string" && id.length > 0 ? id : void 0;
-}
-/**
-* Fork a child box from `checkpointId`. The box exposes `fork` whenever the
-* platform advertised `canFork`; a missing `fork` here is a contract violation
-* (probe said yes, box says no) and fails loud rather than silently degrading.
-*
-* `signal` gates entry only: the legacy SDK's `fork(checkpointId, options)`
-* takes no abort signal, so an in-flight fork cannot be interrupted. The
-* caller checks abort per branch, so cancellation is responsive at boundaries.
-*/
-async function forkFromCheckpoint(box, checkpointId, signal) {
-	const fork = box.fork;
-	if (typeof fork !== "function") throw new ValidationError$1("SandboxLineage.fork: capabilities report canFork but the box has no fork() method");
-	if (signal.aborted) throwAbort();
-	return fork.call(box, checkpointId);
-}
-/**
 * Fail loud when a handle's session is no longer known to the sandbox. The real
 * SDK box exposes `session(id).status()` which resolves `null` for an unknown /
 * reaped id; a `null` here means a `continue` would run WITHOUT the prior
@@ -14909,9 +14445,8 @@ async function setUpLineage(options, maxConcurrency, recordMount, promptOptions,
 	const lineageOpts = options.lineage;
 	if (!lineageOpts || !lineageOpts.sessionContinuity && !lineageOpts.forkFanout) return void 0;
 	if (options.onWorkerBox) throw new ValidationError$1("runAgentRounds: `lineage` and `onWorkerBox` both own worker boxes — pass only one");
-	const capabilities = await probeSandboxCapabilities(options.ctx.sandboxClient);
 	return {
-		lineage: createSandboxLineage(options.ctx.sandboxClient, capabilities, {
+		lineage: createSandboxLineage(options.ctx.sandboxClient, {
 			maxConcurrency,
 			streaming: lineageOpts.streaming,
 			recordMount,
@@ -15526,209 +15061,91 @@ const TERMINAL_DECISIONS = [
 ];
 /** True when the kernel stops the loop for this decision value. @stable */
 function isTerminalDecision(decision) {
-	return TERMINAL_DECISIONS.includes(decision);
-}
-function emitRunLoopHook(options, event) {
-	notifyRuntimeHookEvent(options.ctx.hooks, {
-		id: `${event.runId}:${event.target}:${event.phase}${event.stepIndex === void 0 ? "" : `:${event.stepIndex}`}`,
-		runId: event.runId,
-		target: event.target,
-		phase: event.phase,
-		timestamp: event.timestamp,
-		stepIndex: event.stepIndex,
-		payload: event.payload,
-		metadata: { producer: "run-loop" }
-	}, { signal: options.ctx.signal });
-}
-async function emitTrace(emitter, event) {
-	if (!emitter) return;
-	await emitter.emit(event);
-}
-/**
-* Stable hash for the trace payload. Not cryptographic — only used so
-* downstream eval pipelines can group iterations whose task / output is the
-* same. Bare structural hash; non-JSON values stringify via their `toString`.
-*/
-function hashJson(value) {
-	let str;
-	try {
-		str = JSON.stringify(value) ?? String(value);
-	} catch {
-		str = String(value);
-	}
-	let h = 2166136261;
-	for (let i = 0; i < str.length; i += 1) {
-		h ^= str.charCodeAt(i);
-		h = Math.imul(h, 16777619);
-	}
-	return (h >>> 0).toString(16).padStart(8, "0");
-}
-//#endregion
-//#region src/runtime/sandbox-executor-output.ts
-/** Project the complete Sandbox event stream into the standard executor result shape. */
-function sandboxLeafOutputFromEvents(events) {
-	const content = collectAgentFinalMessageText(events) ?? collectAgentResponseText(events);
-	const toolCalls = sandboxToolCalls(events);
-	const servedBackend = lastServedBackend(events);
-	return {
-		events,
-		content,
-		output: sandboxOutputMarker(content, events.some(carriesText)),
-		...servedBackend === void 0 ? {} : { servedBackend },
-		...toolCalls.length === 0 ? {} : { toolCalls }
-	};
-}
-/**
-* Classify observed text into the explicit output marker. `sawTextEvent` says whether the stream
-* carried a text-bearing event at all, which is what separates a box that answered nothing from a
-* box whose answer was never observed.
-*/
-function sandboxOutputMarker(content, sawTextEvent = content !== void 0) {
-	if (content !== void 0 && content.length > 0) return {
-		kind: "text",
-		bytes: Buffer.byteLength(content, "utf8")
-	};
-	return sawTextEvent ? { kind: "empty" } : { kind: "absent" };
-}
-/** True when the event carries a text field a turn's answer could come from, empty or not. */
-function carriesText(event) {
-	if (!event || typeof event !== "object") return false;
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	if (typeof data.finalText === "string" || typeof data.text === "string") return true;
-	if (typeof data.delta === "string") return true;
-	const part = data.part && typeof data.part === "object" ? data.part : void 0;
-	return part !== void 0 && part.type === "text" && typeof part.text === "string";
-}
-/** The last served identity the platform reported across a turn's events, or `undefined`. */
-function lastServedBackend(events) {
-	let served;
-	for (const event of events) {
-		const next = sandboxEventServedBackend(event);
-		if (next !== void 0) served = next;
-	}
-	return served;
-}
-function sandboxToolCalls(events) {
-	const state = createSandboxToolPartState();
-	return events.flatMap((event) => mapSandboxToolEvent(event, state).flatMap((projected) => projected.type === "tool_call" ? [{
-		...projected.toolCallId === void 0 ? {} : { id: projected.toolCallId },
-		name: projected.toolName,
-		arguments: projected.args ?? {}
-	}] : []));
-}
-//#endregion
-//#region src/runtime/supervise/executor-seams.ts
-function assertExactConfigKeys(value, allowed, context) {
-	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
-	if (unknown.length > 0) throw new ValidationError$1(`${context}: unknown fields ${unknown.sort().join(", ")}; execution behavior belongs in AgentProfile`);
-}
-/** Narrow a named seam off the `ExecutorContext`, failing loud when absent — no
-*  silent default for a required external-boundary seam. */
-function readSeam(ctx, key, who) {
-	const seam = ctx.seams[key];
-	if (seam === void 0 || seam === null) throw new ValidationError$1(`${who} executor: missing required seam "${key}" on ExecutorContext`);
-	return seam;
-}
-function readOptionalAbortSignal(ctx, key, who) {
-	const value = ctx.seams[key];
-	if (value === void 0) return void 0;
-	if (value === null || typeof value !== "object" || typeof value.aborted !== "boolean" || typeof value.addEventListener !== "function") throw new ValidationError$1(`${who} executor: seam "${key}" must be an AbortSignal`);
-	return value;
-}
-/** Narrow the Runtime-owned MCP attachment seam. Absent means the run mounts nothing; a present
-*  value must be a named map of MCP servers, never an empty one that would silently mount nothing. */
-function readOptionalMcpAttachments(ctx, key, who) {
-	const value = ctx.seams[key];
-	if (value === void 0) return void 0;
-	const entries = value !== null && typeof value === "object" && !Array.isArray(value) ? Object.entries(value) : void 0;
-	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError$1(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
-	return value;
-}
-//#endregion
-//#region src/runtime/supervise/bridge-config.ts
-const bridgeSeamKey = "bridge";
-/** Internal control seam used by Runtime-owned external supervisors. A completion request stops
-* the next bridge turn; it must not abort the paid request that is already streaming. */
-const bridgeStopSignalKey = "__bridge_stop_signal";
-/** Internal attachment seam used by Runtime-owned external supervisors. The named MCP servers ride
-* beside the AgentProfile as `runtime_attachments`, so the bridge mounts them for the run and keeps
-* them out of its session profile binding. A rebound coordination port therefore cannot move the
-* authored profile digest that binds a durable session. */
-const bridgeRuntimeAttachmentsKey = "__bridge_runtime_attachments";
-const maxBridgeTimeoutMs = 2147483647;
-function isLoopbackBridgeHost(hostname) {
-	const host = hostname.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
-	if (host === "localhost" || host === "::1" || host === "0:0:0:0:0:0:0:1") return true;
-	if (host === "::ffff:127.0.0.1") return true;
-	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/u.test(host);
-}
-function isLoopbackBridgeUrl(value) {
-	try {
-		const target = new URL(value);
-		return (target.protocol === "http:" || target.protocol === "https:") && isLoopbackBridgeHost(target.hostname);
-	} catch {
-		return false;
-	}
-}
-/** Validate and capture the non-serialisable credential service without reading its value. */
-function captureBridgeModelCredential(value, context) {
-	if (value === null || typeof value !== "object") throw new ValidationError$1(`${context}: modelCredential must be an object`);
-	assertExactConfigKeys(value, /* @__PURE__ */ new Set([
-		"baseUrlKey",
-		"key",
-		"provider"
-	]), `${context} modelCredential`);
-	if (typeof value.key !== "string" || value.key.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.key must be a non-empty string`);
-	if (typeof value.baseUrlKey !== "string" || value.baseUrlKey.trim().length === 0) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must be a non-empty string`);
-	if (value.baseUrlKey === value.key) throw new ValidationError$1(`${context}: modelCredential.baseUrlKey must differ from key`);
-	if (!value.provider || typeof value.provider.get !== "function") throw new ValidationError$1(`${context}: modelCredential.provider must implement get(name)`);
-	const captured = {
-		key: value.key,
-		baseUrlKey: value.baseUrlKey
-	};
-	Object.defineProperty(captured, "provider", {
-		configurable: false,
-		enumerable: false,
-		value: value.provider,
-		writable: false
-	});
-	return Object.freeze(captured);
+	return TERMINAL_DECISIONS.includes(decision);
 }
-function validateBridgeModelCredential(value, bridgeUrl, context) {
-	if (value === void 0) return void 0;
-	if (!isLoopbackBridgeUrl(bridgeUrl)) throw new ValidationError$1(`${context}: modelCredential is allowed only for a loopback bridge URL`);
-	return captureBridgeModelCredential(value, context);
+function emitRunLoopHook(options, event) {
+	notifyRuntimeHookEvent(options.ctx.hooks, {
+		id: `${event.runId}:${event.target}:${event.phase}${event.stepIndex === void 0 ? "" : `:${event.stepIndex}`}`,
+		runId: event.runId,
+		target: event.target,
+		phase: event.phase,
+		timestamp: event.timestamp,
+		stepIndex: event.stepIndex,
+		payload: event.payload,
+		metadata: { producer: "run-loop" }
+	}, { signal: options.ctx.signal });
 }
-function resolveProtectedModelBaseUrl(value, context) {
-	let target;
+async function emitTrace(emitter, event) {
+	if (!emitter) return;
+	await emitter.emit(event);
+}
+/**
+* Stable hash for the trace payload. Not cryptographic — only used so
+* downstream eval pipelines can group iterations whose task / output is the
+* same. Bare structural hash; non-JSON values stringify via their `toString`.
+*/
+function hashJson(value) {
+	let str;
 	try {
-		target = new URL(value);
+		str = JSON.stringify(value) ?? String(value);
 	} catch {
-		throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an absolute HTTPS URL`);
+		str = String(value);
 	}
-	if (target.protocol !== "https:" || target.username || target.password || target.search || target.hash) throw new ValidationError$1(`${context}: modelCredential.baseUrl must be an HTTPS URL without credentials, query, or fragment`);
-	return target.toString().replace(/\/$/u, "");
+	return fnv1a32Hex(str);
 }
-/** Resolve only at the outbound boundary. Provider errors are redacted because they may contain
-*  the protected value; diagnostics identify key names, never values or provider errors. */
-async function resolveBridgeModelCredential(credential, context) {
-	if (credential === void 0) return void 0;
-	const resolveValue = async (key) => {
-		let value;
-		try {
-			value = await credential.provider.get(key);
-		} catch {
-			throw new ValidationError$1(`${context}: modelCredential provider failed for '${key}'`);
-		}
-		if (typeof value !== "string" || value.length === 0 || /[\r\n\0]/u.test(value)) throw new ValidationError$1(`${context}: modelCredential provider has no usable value for '${key}'`);
-		return value;
-	};
-	const [token, baseUrl] = await Promise.all([resolveValue(credential.key), resolveValue(credential.baseUrlKey)]);
+//#endregion
+//#region src/runtime/sandbox-executor-output.ts
+/** Project the complete Sandbox event stream into the standard executor result shape. */
+function sandboxLeafOutputFromEvents(events) {
+	const content = collectAgentFinalMessageText(events) ?? collectAgentResponseText(events);
+	const toolCalls = sandboxToolCalls(events);
+	const servedBackend = lastServedBackend(events);
 	return {
-		token,
-		baseUrl: resolveProtectedModelBaseUrl(baseUrl, context)
+		events,
+		content,
+		output: sandboxOutputMarker(content, events.some(carriesText)),
+		...servedBackend === void 0 ? {} : { servedBackend },
+		...toolCalls.length === 0 ? {} : { toolCalls }
 	};
 }
+/**
+* Classify observed text into the explicit output marker. `sawTextEvent` says whether the stream
+* carried a text-bearing event at all, which is what separates a box that answered nothing from a
+* box whose answer was never observed.
+*/
+function sandboxOutputMarker(content, sawTextEvent = content !== void 0) {
+	if (content !== void 0 && content.length > 0) return {
+		kind: "text",
+		bytes: Buffer.byteLength(content, "utf8")
+	};
+	return sawTextEvent ? { kind: "empty" } : { kind: "absent" };
+}
+/** True when the event carries a text field a turn's answer could come from, empty or not. */
+function carriesText(event) {
+	if (!event || typeof event !== "object") return false;
+	const data = event.data && typeof event.data === "object" ? event.data : {};
+	if (typeof data.finalText === "string" || typeof data.text === "string") return true;
+	if (typeof data.delta === "string") return true;
+	const part = data.part && typeof data.part === "object" ? data.part : void 0;
+	return part !== void 0 && part.type === "text" && typeof part.text === "string";
+}
+/** The last served identity the platform reported across a turn's events, or `undefined`. */
+function lastServedBackend(events) {
+	let served;
+	for (const event of events) {
+		const next = sandboxEventServedBackend(event);
+		if (next !== void 0) served = next;
+	}
+	return served;
+}
+function sandboxToolCalls(events) {
+	const state = createSandboxToolPartState();
+	return events.flatMap((event) => mapSandboxToolEvent(event, state).flatMap((projected) => projected.type === "tool_call" ? [{
+		...projected.toolCallId === void 0 ? {} : { id: projected.toolCallId },
+		name: projected.toolName,
+		arguments: projected.args ?? {}
+	}] : []));
+}
 //#endregion
 //#region src/runtime/codex-rollout-store.ts
 const zeroCounters = {
@@ -17179,9 +16596,6 @@ async function cancelBridgeRunToTerminal(seam, run, grace, stopSignal) {
 		await new Promise((resolve) => setTimeout(resolve, 10));
 	}
 }
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 /** Read only the Router-owned one-sided field from an error body. */
 function providerDispatchFromErrorBody(body) {
 	let parsed;
@@ -17197,13 +16611,7 @@ function providerDispatchFromErrorBody(body) {
 }
 //#endregion
 //#region src/runtime/supervise/node-status.ts
-/**
-* Which {@link NodeStatus} values mean the node is finished.
-*
-* `'waiting'` is deliberately NOT terminal: a wait-state node holds no executor, no box and no
-* conserved budget, so it is neither in flight nor settled. Callers that must also exclude it say
-* so at their own site, because "finished" and "not a live worker" are different questions.
-*/
+/** Which {@link NodeStatus} values mean the node is finished. */
 const terminalNodeStatuses = /* @__PURE__ */ new Set([
 	"done",
 	"failed",
@@ -17613,11 +17021,20 @@ function renderPeerMail(message, nonce) {
 function createInbox() {
 	const pending = [];
 	let live = null;
+	let waiters = [];
 	return {
+		nextDelivery() {
+			return new Promise((resolve) => {
+				waiters.push(resolve);
+			});
+		},
 		deliver(msg) {
 			const m = parseDown(msg);
 			if (!m) return false;
 			pending.push(m);
+			const woken = waiters;
+			waiters = [];
+			for (const wake of woken) wake();
 			if (m.interrupt && live && !live.signal.aborted) live.abort();
 			return true;
 		},
@@ -19171,8 +18588,7 @@ function createSteerableSandboxSession(args) {
 		let preservationFailure;
 		let preservationError;
 		let executionFailure;
-		const capabilities = await probeSandboxCapabilities(args.sandboxClient);
-		const lineage = createSandboxLineage(args.sandboxClient, capabilities, {
+		const lineage = createSandboxLineage(args.sandboxClient, {
 			maxConcurrency: 1,
 			failOnDestroyError: args.failOnDestroyError
 		});
@@ -20923,9 +20339,6 @@ function bridgeOutputText(out) {
 		return String(out);
 	}
 }
-function isAsyncIterable$1(value) {
-	return value !== null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
-}
 /**
 * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
 * `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
@@ -21737,7 +21150,13 @@ async function startRetainedInteractiveRun(options) {
 	});
 	return createRetainedInteractiveRunHandle(environment, ref, capabilities, request);
 }
-/** Retry one exact start after its provider response may have been lost. @stable */
+/**
+* Retry one exact start after its provider response may have been lost.
+*
+* Resolves to the handle of the admitted process (resumed through the exact,
+* idempotent start request), or `null` when the provider no longer holds the
+* environment (not found; nothing remains to stop). @stable
+*/
 async function recoverRetainedInteractiveRun(options) {
 	options.signal?.throwIfAborted();
 	if (typeof options.onAdmission !== "function") throw new Error("recoverRetainedInteractiveRun requires an awaited onAdmission durability hook");
@@ -22169,27 +21588,6 @@ function workerInteractiveAdmissionFile(eventDir, workerId, phase) {
 	assertNoSymlinkDescendant(eventDir, dir, "interactive admission");
 	return join(dir, `${canonicalCandidateDigest({ workerId: id }).slice(7).slice(0, 32)}.${phase}.admission.json`);
 }
-/** Read all durable admissions for one worker, oldest phase first. */
-function readWorkerInteractiveAdmissions(eventDir, workerId) {
-	const phases = [
-		"interactive_intent",
-		"interactive_environment",
-		"interactive_started"
-	];
-	const admissions = [];
-	let missingPhase = false;
-	for (const phase of phases) {
-		const file = workerInteractiveAdmissionFile(eventDir, workerId, phase);
-		if (!existsSync(file)) {
-			missingPhase = true;
-			continue;
-		}
-		if (missingPhase) throw new Error(`interactive admission phase '${phase}' exists after a missing earlier phase`);
-		const parsed = JSON.parse(readFileSync(file, "utf8"));
-		admissions.push(parseAdmission(parsed, workerId, phase));
-	}
-	return admissions;
-}
 /**
 * Persist one retained-interactive admission without retaining sensitive start material.
 *
@@ -22848,8 +22246,6 @@ async function prepareScopeResume(opts, events, signal, now, parentId = opts.run
 			view: materializeTreeView(prior),
 			maxSpawnOrdinal: maxSeqOf(prior, (event) => event.kind === "spawned"),
 			maxCursorSeq: reservedCursorFloor(prior),
-			maxWaitOrdinal: maxSeqOf(prior, (event) => event.kind === "waiting"),
-			waits: pendingWaits(prior),
 			keys: keyedAssignments(prior, settled),
 			priorSpend: sumMeasuredSpendFromEvents(prior)
 		}
@@ -23245,6 +22641,18 @@ function registerScopeRetainedOwner(scope, args) {
 				nextSequence: () => state.nextSequence(),
 				now: args.now
 			}),
+			onWorkspaceCapture: workspaceCaptureWriter({
+				journal: args.journal,
+				rootId: args.rootId,
+				nodeId: args.nodeId,
+				nextSequence: () => state.nextSequence(),
+				now: args.now
+			}),
+			onEndOfTurnWork: (work) => {
+				const prior = state.turnEnd;
+				const settled = work.catch(() => void 0);
+				state.turnEnd = prior === void 0 ? settled : Promise.all([prior, settled]).then(() => {});
+			},
 			onResult: async (result) => {
 				scope.signal.throwIfAborted();
 				assertValidSpend(result.spent, "retained owner result");
@@ -23274,10 +22682,16 @@ function registerScopeRetainedOwner(scope, args) {
 function scopeRetainedOwnerContext(scope) {
 	return owners.get(scope)?.context;
 }
-/** Bind cleanup before replay can return an already accepted owner result. */
-function bindScopeRetainedOwnerProvider(scope, provider) {
+/**
+* Bind cleanup before replay can return an already accepted owner result. `checkpointCapture` is
+* where each checkpoint's files are stored before the checkpoint is deleted; without it, no
+* checkpoint of this owner is deleted.
+*/
+function bindScopeRetainedOwnerProvider(scope, provider, checkpointCapture) {
 	const state = owners.get(scope);
-	if (state) state.provider = provider;
+	if (state === void 0) return;
+	state.provider = provider;
+	if (checkpointCapture !== void 0) state.checkpointCapture = checkpointCapture;
 }
 /** Bind the owner cleanup policy selected by its provider executor. */
 function bindScopeRetainedOwnerWorkspaceRetention(scope, enabled) {
@@ -23452,7 +22866,8 @@ async function checkpointOwnerWorkspace(scope, state) {
 		seq: state.nextSequence(),
 		at
 	});
-	await deleteCheckpoints(state, branching, pendingCheckpoints(await args.journal.loadTree(args.rootId) ?? [], state).filter((event) => event.environmentId === environment.id).slice(0, -2), signal);
+	const events = await args.journal.loadTree(args.rootId) ?? [];
+	await cleanCheckpoints(state, branching, pendingCheckpoints(events, state).filter((event) => event.environmentId === environment.id && state.captureRefused?.has(event.checkpoint.checkpointId) !== true).slice(0, -2), events, scope.signal);
 }
 /** Reconstruct authority for this source only; a replacement cannot own its snapshots. */
 async function checkpointHandle(state, sourceEnvironmentId, signal) {
@@ -23475,7 +22890,14 @@ async function checkpointHandle(state, sourceEnvironmentId, signal) {
 		return;
 	}
 }
-/** An aborted observation cannot prove that the provider never created a snapshot. */
+/**
+* An aborted observation cannot prove that the provider never created a snapshot, so a request
+* whose lookup does not find it keeps its source alive for a later lookup, with one exception: a
+* provider that answers `not_found` for a request older than {@link WORKSPACE_CHECKPOINT_ABSENT_AFTER_MS}
+* never created it. No operation that request started can still be in flight, and keeping the
+* source then holds a sandbox for nothing: on Discovery Lab runs terraform-economics-20261005e and
+* f, each root was kept after its run settled over requests made hours earlier.
+*/
 async function reconcileCheckpointRequests(state, events) {
 	const operationKey = (operation) => JSON.stringify([operation.idempotencyKey, operation.requestDigest]);
 	const resolved = new Set(events.flatMap((event) => event.kind === "workspace-checkpoint" && event.id === state.args.nodeId && event.provider === state.provider?.name ? [operationKey(event.checkpoint)] : []));
@@ -23490,7 +22912,29 @@ async function reconcileCheckpointRequests(state, events) {
 				idempotencyKey: event.request.idempotencyKey,
 				requestDigest: event.request.requestDigest
 			}, { signal }), signal, "retained owner checkpoint lookup timed out");
-			if (result.status !== "found" || !workspaceCheckpointResultMatchesRequest(event.request, result)) throw new Error("checkpoint operation outcome is unresolved");
+			if (result.status === "not_found") {
+				const requestedAt = Date.parse(event.at);
+				if (Number.isFinite(requestedAt) && state.args.now() - requestedAt >= 12e5) continue;
+				unconfirmed.push({
+					event,
+					reason: "lookup not_found while the request may be in flight"
+				});
+				continue;
+			}
+			if (result.status !== "found") {
+				unconfirmed.push({
+					event,
+					reason: `lookup ${result.status}${"message" in result && result.message ? `: ${result.message}` : ""}`
+				});
+				continue;
+			}
+			if (!workspaceCheckpointResultMatchesRequest(event.request, result)) {
+				unconfirmed.push({
+					event,
+					reason: "lookup found a checkpoint for another request"
+				});
+				continue;
+			}
 			const recovered = {
 				kind: "workspace-checkpoint",
 				id: event.id,
@@ -23503,8 +22947,11 @@ async function reconcileCheckpointRequests(state, events) {
 			};
 			await state.args.journal.appendEvent(state.args.rootId, recovered);
 			events.push(recovered);
-		} catch {
-			unconfirmed.push(event);
+		} catch (error) {
+			unconfirmed.push({
+				event,
+				reason: `lookup failed: ${errorText(error instanceof Error ? error.message : error)}`
+			});
 		}
 	}
 	return unconfirmed;
@@ -23513,10 +22960,35 @@ function pendingCheckpoints(events, state) {
 	const confirmed = new Set(events.flatMap((event) => event.kind === "workspace-checkpoint-cleanup" && event.id === state.args.nodeId && event.provider === state.provider?.name && event.confirmed ? [JSON.stringify([event.environmentId, event.checkpointId])] : []));
 	return events.filter((event) => event.kind === "workspace-checkpoint" && event.id === state.args.nodeId && event.provider === state.provider?.name && !confirmed.has(JSON.stringify([event.environmentId, event.checkpoint.checkpointId])));
 }
-/** Only the source-scoped handle can attest deletion, including after its source is lost. */
-async function deleteCheckpoints(state, branching, checkpoints, signal) {
+/**
+* Delete checkpoints, each only after its files are captured into the run's content-addressed
+* store; a checkpoint no capture holds is kept, and the cleanup record says why. Only the
+* source-scoped handle can fork a checkpoint and attest its deletion, including after its source
+* is lost. `parent` cancels the captures (the owner's scope during rotation); each provider
+* operation also has its own bound.
+*/
+async function cleanCheckpoints(state, branching, checkpoints, events, parent) {
 	const unconfirmed = [];
+	const refused = [];
 	for (const event of checkpoints) {
+		const captured = await captureBeforeCleanup(state, branching, event, events, parent);
+		if ("reason" in captured) {
+			(state.captureRefused ??= /* @__PURE__ */ new Set()).add(event.checkpoint.checkpointId);
+			refused.push(captured);
+			await state.args.journal.appendEvent(state.args.rootId, {
+				kind: "workspace-checkpoint-cleanup",
+				id: state.args.nodeId,
+				provider: event.provider,
+				environmentId: event.environmentId,
+				checkpointId: event.checkpoint.checkpointId,
+				confirmed: false,
+				refused: captured.reason.slice(0, 1e3),
+				seq: state.nextSequence(),
+				at: new Date(state.args.now()).toISOString()
+			});
+			continue;
+		}
+		state.captureRefused?.delete(event.checkpoint.checkpointId);
 		const material = {
 			kind: "checkpoint",
 			targetId: event.checkpoint.checkpointId,
@@ -23530,6 +23002,7 @@ async function deleteCheckpoints(state, branching, checkpoints, signal) {
 		let confirmed = false;
 		try {
 			if (branching === void 0) throw new Error("source-scoped checkpoint handle unavailable");
+			const signal = AbortSignal.timeout(3e4);
 			const acknowledgement = await runAbortable(() => branching.deleteCheckpoint(request, { signal }), signal, "retained owner checkpoint cleanup timed out");
 			confirmed = workspaceCleanupAcknowledgementMatches(request, acknowledgement) && (acknowledgement.status === "deleted" || acknowledgement.status === "already_absent");
 		} catch {}
@@ -23541,11 +23014,178 @@ async function deleteCheckpoints(state, branching, checkpoints, signal) {
 			environmentId: event.environmentId,
 			checkpointId: event.checkpoint.checkpointId,
 			confirmed,
+			capturedDigest: captured.digest,
 			seq: state.nextSequence(),
 			at: new Date(state.args.now()).toISOString()
 		});
 	}
-	return unconfirmed;
+	return {
+		unconfirmed,
+		refused
+	};
+}
+/**
+* The digest of the tree that holds a checkpoint's files, capturing it first when no record says
+* one exists, or why it cannot be had. The files are read from a fork of the checkpoint: a box
+* created from the snapshot itself, so the capture is the checkpoint's state and not the live
+* workspace's, which has moved on. The fork request is journaled before it is made and the fork
+* destroyed once the capture is journaled, so neither a failure nor a crash leaves it running
+* unrecorded.
+*/
+async function captureBeforeCleanup(state, branching, event, events, parent) {
+	const { args } = state;
+	const checkpointId = event.checkpoint.checkpointId;
+	const recorded = events.find((prior) => prior.kind === "workspace-checkpoint-capture" && prior.id === args.nodeId && prior.provider === event.provider && prior.environmentId === event.environmentId && prior.checkpointId === checkpointId);
+	if (recorded !== void 0) return { digest: recorded.tree.digest };
+	const refuse = (reason, needsSource) => ({
+		event,
+		reason,
+		needsSource
+	});
+	const capture = state.checkpointCapture;
+	if (capture?.port.captureCheckpoint === void 0) return refuse("no checkpoint capture: the owner backend has no captureCheckpoint", false);
+	const provider = state.provider;
+	if (provider?.get === void 0) return refuse("the provider cannot reconstruct a fork of the checkpoint", false);
+	if (branching === void 0) return refuse("source-scoped checkpoint handle unavailable", true);
+	const material = {
+		checkpoint: event.checkpoint,
+		placement: { kind: "sandbox" }
+	};
+	const request = {
+		...material,
+		idempotencyKey: `${event.checkpoint.idempotencyKey}:capture:${state.nextSequence()}`,
+		requestDigest: workspaceForkRequestDigest(material)
+	};
+	const forkSignal = AbortSignal.any([...parent === void 0 ? [] : [parent], AbortSignal.timeout(WORKSPACE_CHECKPOINT_FORK_TIMEOUT_MS)]);
+	let forkEnvironmentId;
+	try {
+		await args.journal.appendEvent(args.rootId, {
+			kind: "workspace-checkpoint-fork-requested",
+			id: args.nodeId,
+			provider: event.provider,
+			environmentId: event.environmentId,
+			checkpointId,
+			idempotencyKey: request.idempotencyKey,
+			requestDigest: request.requestDigest,
+			seq: state.nextSequence(),
+			at: new Date(args.now()).toISOString()
+		});
+		const result = await runAbortable(() => branching.fork(request, { signal: forkSignal }), forkSignal, "checkpoint fork timed out");
+		if (result.status === "created" || result.status === "replayed") forkEnvironmentId = result.environment.environmentId;
+		if (result.status !== "created" && result.status !== "replayed" || !workspaceForkResultMatchesRequest(request, result)) return refuse(`fork ${result.status}${"message" in result ? `: ${result.message}` : ""}`, true);
+		const forkId = result.environment.environmentId;
+		const get = provider.get.bind(provider);
+		const environment = await runAbortable(() => get(forkId), forkSignal, "checkpoint fork lookup timed out");
+		if (environment === null || environment.id !== forkId || environment.provider !== provider.name) return refuse(`fork ${forkId} could not be reconstructed`, true);
+		parent?.throwIfAborted();
+		const tree = await captureProviderCheckpointWorkspace(capture.port, {
+			environment,
+			checkpoint: event.checkpoint,
+			executionId: `${args.nodeId}:checkpoint:${checkpointId}`,
+			profile: capture.profile
+		}, event.marker);
+		await args.journal.appendEvent(args.rootId, {
+			kind: "workspace-checkpoint-capture",
+			id: args.nodeId,
+			provider: event.provider,
+			environmentId: event.environmentId,
+			checkpointId,
+			fork: {
+				idempotencyKey: request.idempotencyKey,
+				environmentId: forkId
+			},
+			tree: {
+				digest: tree.digest,
+				manifest: tree.manifest,
+				files: tree.files,
+				bytes: tree.bytes,
+				storedBytes: tree.storedBytes
+			},
+			seq: state.nextSequence(),
+			at: new Date(args.now()).toISOString()
+		});
+		return { digest: tree.digest };
+	} catch (error) {
+		return refuse(`capture failed: ${errorText(error instanceof Error ? error.message : error)}`, true);
+	} finally {
+		if (forkEnvironmentId !== void 0) await destroyCaptureFork(state, branching, {
+			provider: event.provider,
+			environmentId: event.environmentId,
+			checkpointId,
+			fork: {
+				idempotencyKey: request.idempotencyKey,
+				environmentId: forkEnvironmentId
+			}
+		});
+	}
+}
+/** Destroy a capture's fork and journal whether the provider confirmed it. */
+async function destroyCaptureFork(state, branching, target) {
+	const material = {
+		kind: "fork",
+		targetId: target.fork.environmentId,
+		provider: target.provider
+	};
+	const request = {
+		...material,
+		operationId: `${target.fork.idempotencyKey}:destroy`,
+		requestDigest: workspaceCleanupRequestDigest(material)
+	};
+	let destroyed = false;
+	try {
+		const signal = AbortSignal.timeout(3e4);
+		const acknowledgement = await runAbortable(() => branching.destroyFork(request, { signal }), signal, "checkpoint capture fork cleanup timed out");
+		destroyed = workspaceCleanupAcknowledgementMatches(request, acknowledgement) && (acknowledgement.status === "deleted" || acknowledgement.status === "already_absent");
+	} catch {}
+	await state.args.journal.appendEvent(state.args.rootId, {
+		kind: "workspace-checkpoint-fork-teardown",
+		id: state.args.nodeId,
+		...target,
+		destroyed,
+		seq: state.nextSequence(),
+		at: new Date(state.args.now()).toISOString()
+	});
+	return destroyed;
+}
+/**
+* Destroy every capture fork the journal does not show destroyed: one a crash left between its
+* request and its teardown, or whose teardown the provider did not confirm. Returns the forks
+* still not confirmed destroyed, by environment or, when none was ever named, by request key.
+*/
+async function settleCaptureForks(state) {
+	const { args } = state;
+	const providerName = state.provider?.name;
+	const events = (await args.journal.loadTree(args.rootId) ?? []).filter((event) => event.id === args.nodeId);
+	const named = (key) => {
+		for (const event of events) if ((event.kind === "workspace-checkpoint-capture" || event.kind === "workspace-checkpoint-fork-teardown") && event.fork.idempotencyKey === key) return event.fork.environmentId;
+	};
+	const destroyed = new Set(events.flatMap((event) => event.kind === "workspace-checkpoint-fork-teardown" && event.destroyed ? [event.fork.idempotencyKey] : []));
+	const unresolved = [];
+	for (const request of events) {
+		if (request.kind !== "workspace-checkpoint-fork-requested" || request.provider !== providerName) continue;
+		if (destroyed.has(request.idempotencyKey)) continue;
+		const signal = AbortSignal.timeout(3e4);
+		const branching = await checkpointHandle(state, request.environmentId, signal);
+		let forkEnvironmentId = named(request.idempotencyKey);
+		if (forkEnvironmentId === void 0 && branching !== void 0) try {
+			const found = await runAbortable(() => branching.lookupFork({
+				idempotencyKey: request.idempotencyKey,
+				requestDigest: request.requestDigest
+			}, { signal }), signal, "checkpoint capture fork lookup timed out");
+			if (found.status === "not_found") continue;
+			if (found.status === "found") forkEnvironmentId = found.environment.environmentId;
+		} catch {}
+		if (forkEnvironmentId === void 0 || branching === void 0 || !await destroyCaptureFork(state, branching, {
+			provider: request.provider,
+			environmentId: request.environmentId,
+			checkpointId: request.checkpointId,
+			fork: {
+				idempotencyKey: request.idempotencyKey,
+				environmentId: forkEnvironmentId
+			}
+		})) unresolved.push(forkEnvironmentId ?? request.idempotencyKey);
+	}
+	return unresolved;
 }
 /**
 * The checkpoint a new environment of this owner starts from: the latest one journaled before
@@ -23565,33 +23205,111 @@ async function restoreCapable(provider) {
 	}
 }
 /**
-* What the owner's next new environment will hold of the lost one, read before the drive so the
-* re-entered director is told: the checkpoint's time, or undefined when there is nothing to
-* restore.
+* What the owner's next new environment will hold of the lost one, read before the drive so the
+* re-entered director is told: the checkpoint's time, or undefined when there is nothing to
+* restore.
+*/
+async function scopeRetainedOwnerRestorePoint(scope) {
+	const state = owners.get(scope);
+	if (state === void 0 || !await restoreCapable(state.provider)) return void 0;
+	const latest = restoreBefore((await state.args.journal.loadTree(state.args.rootId) ?? []).filter((event) => event.id === state.args.nodeId), -1);
+	return latest === void 0 ? void 0 : {
+		checkpointId: latest.checkpoint.checkpointId,
+		takenAt: latest.at
+	};
+}
+/** @internal Whether another owner release could still destroy what the last one left. */
+function retainedOwnerReleaseRetriable(scope) {
+	return owners.get(scope)?.releaseRetriable ?? false;
+}
+/**
+* Mark one drive of the owner in progress until the returned function is called. An abort settles
+* the node while the drive is still ending its turn: stopping the harness, copying its session and
+* handing its workspace capture over. A release that ran then would find no receipt for the turn
+* and keep the source alive, as on terraform-economics-20261005f, where the root's last attempt was
+* recorded two minutes after its environment's release.
+*/
+function beginScopeRetainedOwnerDrive(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return () => {};
+	let end;
+	const drive = new Promise((resolve) => {
+		end = resolve;
+	});
+	state.drive = drive;
+	return () => {
+		end();
+		if (state.drive === drive) delete state.drive;
+	};
+}
+/** Wait, bounded like a turn's own ending, for the owner's drive in progress to end. */
+async function ownerDriveEnded(state) {
+	const drive = state.drive;
+	if (drive === void 0) return;
+	let timer;
+	try {
+		await Promise.race([drive, new Promise((resolve) => {
+			timer = setTimeout(resolve, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/**
+* Wait for the end-of-turn work the owner's last turn handed over: its workspace capture and the
+* evidence record of its receipt. A turn hands it over so that its node settles without it; the
+* owner's next turn and its environment's release wait for it here.
+*/
+async function scopeRetainedOwnerTurnEnded(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return;
+	for (;;) {
+		const pending = state.turnEnd;
+		if (pending === void 0) return;
+		await pending;
+		if (state.turnEnd === pending) {
+			delete state.turnEnd;
+			return;
+		}
+	}
+}
+/** @internal Wait for everything this owner still has in flight: the drive ending its turn, the
+*  work that turn handed over, and a release. */
+async function scopeRetainedOwnerSettled(scope) {
+	const state = owners.get(scope);
+	if (state === void 0) return;
+	await ownerDriveEnded(state);
+	await scopeRetainedOwnerTurnEnded(scope);
+	await state.releasing?.catch(() => void 0);
+}
+/**
+* Release the owner's environment once no turn of it will run again: at the run's final
+* settlement for the root, and when a nested manager's own scope has finished. A second call while
+* one is in flight joins it. The release first waits for the end-of-turn capture of the owner's
+* last turn, so the capture always precedes the destroy.
 */
-async function scopeRetainedOwnerRestorePoint(scope) {
+function releaseScopeRetainedOwnerEnvironment(scope) {
 	const state = owners.get(scope);
-	if (state === void 0 || !await restoreCapable(state.provider)) return void 0;
-	const latest = restoreBefore((await state.args.journal.loadTree(state.args.rootId) ?? []).filter((event) => event.id === state.args.nodeId), -1);
-	return latest === void 0 ? void 0 : {
-		checkpointId: latest.checkpoint.checkpointId,
-		takenAt: latest.at
-	};
-}
-/** @internal Whether another owner release could still destroy what the last one left. */
-function retainedOwnerReleaseRetriable(scope) {
-	return owners.get(scope)?.releaseRetriable ?? false;
+	const provider = state?.provider;
+	if (state === void 0 || provider === void 0) return Promise.resolve([]);
+	if (state.releasing !== void 0) return state.releasing;
+	const tracked = (async () => {
+		await ownerDriveEnded(state);
+		await scopeRetainedOwnerTurnEnded(scope);
+		return await releaseOwnerEnvironment(state, provider);
+	})().finally(() => {
+		if (state.releasing === tracked) delete state.releasing;
+	});
+	state.releasing = tracked;
+	return tracked;
 }
-/** The existing scope settlement barrier releases the owner's environment after all its turns. */
-async function releaseScopeRetainedOwnerEnvironment(scope) {
-	const state = owners.get(scope);
-	if (!state?.provider) return [];
-	const { provider, args } = state;
+async function releaseOwnerEnvironment(state, provider) {
+	const { args } = state;
 	state.checkpointsUnavailable ??= "released";
 	await state.checkpointing?.catch(() => void 0);
 	const events = [...await args.journal.loadTree(args.rootId) ?? []];
 	const requestFailures = await reconcileCheckpointRequests(state, events);
-	const pendingSources = new Set(requestFailures.map((event) => event.environmentId));
+	const pendingSources = new Set(requestFailures.map(({ event }) => event.environmentId));
 	const released = new Set(events.flatMap((event) => event.kind === "environment-teardown" && event.id === args.nodeId && event.provider === provider.name && event.destroyed ? [event.environmentId] : []));
 	const environments = new Set(events.flatMap((event) => event.id === args.nodeId && event.kind === "execution-admitted" && event.admission.phase === "environment" ? [event.admission.environmentId] : []));
 	const retentionFailures = state.workspaceRetention || events.some((event) => event.kind === "execution-input" && event.id === args.nodeId && event.workspaceRetention === true) ? await ownerWorkspaceRetentionFailures(events, args.nodeId, args.blobs) : /* @__PURE__ */ new Set();
@@ -23600,19 +23318,23 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 	let lastDetail;
 	let retriable = false;
 	const checkpointFailures = [];
+	const checkpointsKept = [];
+	const uncapturedSources = /* @__PURE__ */ new Set();
 	const pending = pendingCheckpoints(events, state).filter((event) => !retentionFailures.has(event.environmentId));
 	for (const sourceEnvironmentId of new Set(pending.map((event) => event.environmentId))) {
-		const signal = AbortSignal.timeout(3e4);
-		const branching = await checkpointHandle(state, sourceEnvironmentId, signal);
-		checkpointFailures.push(...await deleteCheckpoints(state, branching, pending.filter((event) => event.environmentId === sourceEnvironmentId), signal));
+		const cleaned = await cleanCheckpoints(state, await checkpointHandle(state, sourceEnvironmentId, AbortSignal.timeout(3e4)), pending.filter((event) => event.environmentId === sourceEnvironmentId), events);
+		checkpointFailures.push(...cleaned.unconfirmed);
+		checkpointsKept.push(...cleaned.refused);
+		for (const refusal of cleaned.refused) if (refusal.needsSource) uncapturedSources.add(sourceEnvironmentId);
 	}
+	const forksUnresolved = await settleCaptureForks(state);
 	for (const event of checkpointFailures) pendingSources.add(event.environmentId);
 	for (const environmentId of environments) {
 		if (released.has(environmentId)) continue;
 		let destroyed = false;
 		let detail;
-		if (retentionFailures.has(environmentId) || pendingSources.has(environmentId)) {
-			detail = pendingSources.has(environmentId) ? "checkpoint cleanup unresolved: source preserved for exact lookup and cleanup" : "provider workspace retention: source preserved because the owner execution has no verified workspace receipt";
+		if (retentionFailures.has(environmentId) || pendingSources.has(environmentId) || uncapturedSources.has(environmentId)) {
+			detail = pendingSources.has(environmentId) ? "checkpoint cleanup unresolved: source preserved for exact lookup and cleanup" : uncapturedSources.has(environmentId) ? "checkpoint kept uncaptured: source preserved so its checkpoint can still be forked and captured" : "provider workspace retention: source preserved because the owner execution has no verified workspace receipt";
 			preserved.push(environmentId);
 			lastDetail = detail;
 		} else {
@@ -23668,19 +23390,36 @@ async function releaseScopeRetainedOwnerEnvironment(scope) {
 		});
 	}
 	state.releaseRetriable = retriable;
-	const checkpointTeardowns = [...checkpointFailures.map((event) => ({
-		id: args.nodeId,
-		label: "scope owner workspace checkpoint",
-		runtime: provider.name,
-		status: "done",
-		detail: `checkpoint cleanup unconfirmed: ${event.checkpoint.checkpointId} from ${event.environmentId}`
-	})), ...requestFailures.map((event) => ({
-		id: args.nodeId,
-		label: "scope owner checkpoint request",
-		runtime: provider.name,
-		status: "done",
-		detail: `checkpoint request unresolved: ${event.request.idempotencyKey} from ${event.environmentId}`
-	}))];
+	const checkpointTeardowns = [
+		...checkpointFailures.map((event) => ({
+			id: args.nodeId,
+			label: "scope owner workspace checkpoint",
+			runtime: provider.name,
+			status: "done",
+			detail: `checkpoint cleanup unconfirmed: ${event.checkpoint.checkpointId} from ${event.environmentId}`
+		})),
+		...requestFailures.map(({ event, reason }) => ({
+			id: args.nodeId,
+			label: "scope owner checkpoint request",
+			runtime: provider.name,
+			status: "done",
+			detail: `checkpoint request unresolved: ${event.request.idempotencyKey} from ${event.environmentId} (${reason})`
+		})),
+		...checkpointsKept.map(({ event, reason }) => ({
+			id: args.nodeId,
+			label: "scope owner workspace checkpoint",
+			runtime: provider.name,
+			status: "done",
+			detail: `checkpoint kept uncaptured: ${event.checkpoint.checkpointId} from ${event.environmentId} (${reason})`
+		})),
+		...forksUnresolved.length === 0 ? [] : [{
+			id: args.nodeId,
+			label: "scope owner checkpoint capture fork",
+			runtime: provider.name,
+			status: "done",
+			detail: `checkpoint capture fork destruction unconfirmed: ${forksUnresolved.join(", ")}`
+		}]
+	];
 	return unconfirmed.length > 0 || preserved.length > 0 ? [{
 		id: args.nodeId,
 		label: "scope owner",
@@ -23718,7 +23457,15 @@ function unsettledOwnerRuns(events, nodeId, environmentId) {
 	close();
 	return [...runs.values()];
 }
-/** Group owner admissions by input and require a verified workspace receipt before deletion. */
+/**
+* Group owner admissions by input and require a verified workspace receipt before deletion.
+*
+* The receipt is the attempt's committed result, or an evidence record of the same attempt: a
+* turn its manager stopped commits its result first and journals its capture as evidence after
+* it, and a turn that failed journals the capture it took of the stopped session. This runs only
+* at a release no process will resume, so a complete, verified capture of the exact execution is
+* the whole of what keeping the source would preserve.
+*/
 async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 	const attempts = [];
 	let current;
@@ -23726,30 +23473,26 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 		if (current !== void 0) attempts.push(current);
 		current = void 0;
 	};
+	const fresh = (executionId) => ({
+		...executionId === void 0 ? {} : { executionId },
+		environmentIds: /* @__PURE__ */ new Set(),
+		controlByEnvironment: /* @__PURE__ */ new Map(),
+		evidence: []
+	});
 	for (const event of events) {
 		if (!("id" in event) || event.id !== nodeId) continue;
 		if (event.kind === "execution-input") {
 			flush();
-			current = {
-				executionId: `${nodeId}:input:${event.seq}`,
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current = fresh(`${nodeId}:input:${event.seq}`);
 		} else if (event.kind === "execution-admitted" && event.admission.phase === "environment") {
 			if (current?.result !== void 0) flush();
-			current ??= {
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current ??= fresh();
 			current.environmentIds.add(event.admission.environmentId);
 		} else if (event.kind === "execution-admitted" && event.admission.phase === "dispatched") current?.controlByEnvironment.set(event.admission.controlRef.environmentId, event.admission.controlRef);
 		else if (event.kind === "execution-result") {
-			current ??= {
-				environmentIds: /* @__PURE__ */ new Set(),
-				controlByEnvironment: /* @__PURE__ */ new Map()
-			};
+			current ??= fresh();
 			current.result = event;
-		}
+		} else if (event.kind === "execution-evidence") current?.evidence.push(event);
 	}
 	flush();
 	const failures = /* @__PURE__ */ new Set();
@@ -23759,25 +23502,30 @@ async function ownerWorkspaceRetentionFailures(events, nodeId, blobs) {
 			for (const environmentId of attempt.environmentIds) failures.add(environmentId);
 			continue;
 		}
-		const result = attempt.result;
-		if (result === void 0) {
-			for (const environmentId of attempt.environmentIds) failures.add(environmentId);
-			continue;
-		}
-		let output;
-		try {
-			output = await blobs.get(result.outRef);
-			if (output === void 0 || contentAddress(output) !== result.outRef) throw new Error();
-		} catch {
-			output = void 0;
-		}
-		const snapshot = output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0;
 		const environmentId = [...attempt.environmentIds][0];
 		const controlRef = attempt.controlByEnvironment.get(environmentId);
-		if (!hasDurableWorkspaceCapture(output, snapshot, environmentId, attempt.executionId, controlRef)) failures.add(environmentId);
+		const receipts = [...attempt.result === void 0 ? [] : [attempt.result.outRef], ...attempt.evidence.map((event) => event.outRef)];
+		let verified = false;
+		for (const outRef of receipts) {
+			const output = await storedOutput(blobs, outRef);
+			if (hasDurableWorkspaceCapture(output, output !== null && typeof output === "object" ? output.workspaceSnapshot : void 0, environmentId, attempt.executionId, controlRef)) {
+				verified = true;
+				break;
+			}
+		}
+		if (!verified) failures.add(environmentId);
 	}
 	return failures;
 }
+/** A stored output whose bytes match its content reference, or undefined. */
+async function storedOutput(blobs, outRef) {
+	try {
+		const output = await blobs.get(outRef);
+		return output === void 0 || contentAddress(output) !== outRef ? void 0 : output;
+	} catch {
+		return;
+	}
+}
 /** A stored result authorizes cleanup only for the exact source and complete capture. */
 function hasDurableWorkspaceCapture(output, snapshot, environmentId, executionId, controlRef) {
 	const parsed = agentCandidateWorkspaceSnapshotEvidenceSchema.safeParse(snapshot);
@@ -23976,180 +23724,6 @@ function consumeScopeRetainedOwnerResult(scope) {
 	state.acceptedConsumed = true;
 }
 //#endregion
-//#region src/runtime/supervise/wait.ts
-/**
-*
-* WAIT-STATES — a supervision-tree node that waits on wall-clock time or an external condition
-* without holding a worker, an executor, a sandbox, or a single LLM turn.
-*
-* A long-horizon run spends most of its wall-clock NOT computing: waiting for CI to finish,
-* for a nightly job to land, for a human to reply, for a rate-limit window to reopen. Before
-* this, the only way to express that was to keep something alive and re-ask — which spends
-* driver tokens per re-ask and pins a process to the wait.
-*
-* Two node kinds, both first-class:
-*   - `timer` — wake at an ABSOLUTE wall-clock instant (`untilMs`).
-*   - `poll`  — re-run a named predicate every `intervalMs` until it returns true, or until an
-*               absolute `timeoutAtMs` passes (CI status, file existence, an HTTP probe, an
-*               inbox message).
-*
-* ── How this differs from `await_event`'s 45s poll fence (`DEFAULT_AWAIT_EVENT_TIMEOUT_MS`) ──
-*
-* They look similar and are not the same mechanism. `await_event` is an IN-RUN RENDEZVOUS: the
-* driver blocks on the coordination bus for the next event from a live worker, and the 45s fence
-* exists only so a remote MCP request does not exceed the client's timeout — the caller re-polls.
-* Every re-poll is another driver inference turn (real tokens) against a process that must stay
-* up, and nothing about that wait is recorded: kill the process and the wait is simply gone.
-*
-* A wait-state is a NODE, not a call. It has a node id in the tree, a journal record carrying its
-* ABSOLUTE deadline, and it settles through the same `Scope.next()` cursor as any worker. Nobody
-* is blocked on it — the driver can stop reasoning entirely, and the process can die. Cost while
-* waiting: zero LLM calls, zero executor, zero sandbox, zero conserved budget (a wait reserves
-* nothing from the pool). The only in-process residue is one timer entry.
-*
-* ── Why probes are NAMED, not passed as closures ────────────────────────────────────────────
-*
-* A wait must survive a process restart with its original deadline intact, and a closure cannot
-* be journaled. So a `poll` names its predicate (`probe: 'ci-green'`) and the run resolves it
-* through a `WaitProbeRegistry`. A brand-new process re-resolves the SAME name against its own
-* registry and re-arms the wait — which is what makes "kill the box, the wait keeps waiting"
-* true rather than aspirational.
-*
-* Absolute instants for the same reason: `untilMs` / `timeoutAtMs` are epoch ms, not durations,
-* so a resumed wait counts down from the original arm, not from the restart. `timerAt`/`pollFor`
-* build them from a duration when that is what the caller has.
-*
-* @experimental
-*/
-/** Build a `timer` spec from a DURATION. The instant is resolved once, at arm time — a resumed
-*  wait re-uses the journaled instant, never a fresh `now + ms`. */
-function timerAt(ms, now) {
-	return {
-		kind: "timer",
-		untilMs: now + ms
-	};
-}
-/** Build a bounded `poll` spec from a duration. */
-function pollFor(probe, opts, now) {
-	return {
-		kind: "poll",
-		probe,
-		intervalMs: opts.intervalMs,
-		...opts.timeoutMs !== void 0 ? { timeoutAtMs: now + opts.timeoutMs } : {},
-		...opts.args ? { args: opts.args } : {}
-	};
-}
-/** Registry over a plain name→predicate record. */
-function createWaitProbes(entries) {
-	const map = new Map(Object.entries(entries));
-	return { resolve: (name) => map.get(name) };
-}
-/** Narrow a settlement's `out` to a wait outcome — a wait settles on the SAME cursor as workers,
-*  so a driver that mixes them tags them apart with this. */
-function isWaitOutcome(value) {
-	return typeof value === "object" && value !== null && value.waitOutcome === true;
-}
-/** The absolute instant a spec is bounded by, or `undefined` for an unbounded wait. */
-function waitUntil(spec) {
-	if (spec.kind === "timer") return spec.untilMs;
-	if (spec.kind === "token") return spec.expiresAtMs;
-	return spec.timeoutAtMs;
-}
-/** Structural validation, independent of the run. Returns null when the spec is usable. */
-function validateWaitSpec(spec) {
-	if (spec.kind === "timer") return Number.isFinite(spec.untilMs) ? null : "timer.untilMs must be a finite epoch-ms instant";
-	if (spec.kind === "token") return "token waits are graph-engine-owned; deliver them through engine resume/expire";
-	if (typeof spec.probe !== "string" || spec.probe.length === 0) return "poll.probe must be a non-empty probe name";
-	if (!Number.isFinite(spec.intervalMs) || spec.intervalMs <= 0) return "poll.intervalMs must be > 0";
-	if (spec.timeoutAtMs !== void 0 && !Number.isFinite(spec.timeoutAtMs)) return "poll.timeoutAtMs must be a finite epoch-ms instant";
-	return null;
-}
-/**
-* A wait must not silently outlive the run's HARD wall-clock ceiling. When the conserved pool
-* carries an absolute `deadlineMs`, a wait bounded past it — or an unbounded poll — is REFUSED at
-* arm time (`deadline-exceeded`) rather than sleeping through a ceiling the caller already set.
-* The alternative (extending the pool's deadline to cover the wait) would let a wait override a
-* hard budget guard, which is exactly what mechanic D forbids; a run that intends week-long waits
-* either sets a deadline that covers them or sets none.
-*/
-function assertWaitWithinDeadline(spec, deadlineMs) {
-	if (deadlineMs <= 0) return true;
-	const until = waitUntil(spec);
-	if (until === void 0) return false;
-	return until <= deadlineMs;
-}
-/**
-* Drive one wait to its resolution. Spends nothing: a `timer` is one sleep, a `poll` is a sleep
-* between predicate checks. No LLM call, no executor, no box, no budget reservation.
-*/
-async function runWait(args) {
-	const { spec, label, armedAt, resumed, signal, now } = args;
-	const sleep = args.sleep ?? defaultSleep$1;
-	if (signal.aborted) return {
-		kind: "cancelled",
-		reason: "aborted before arming"
-	};
-	if (spec.kind === "timer") {
-		const remaining = spec.untilMs - now();
-		if (remaining > 0) await sleep(remaining, signal);
-		if (signal.aborted) return {
-			kind: "cancelled",
-			reason: "wait aborted"
-		};
-		return {
-			kind: "woke",
-			outcome: outcome("timer", "fired", label, spec.untilMs, armedAt, now(), 0, 0, resumed)
-		};
-	}
-	if (spec.kind === "token") throw new ValidationError$1(`wait '${label}': token waits are graph-engine-owned; deliver them through engine resume/expire`);
-	const probe = args.probes?.resolve(spec.probe);
-	if (!probe) throw new ValidationError$1(`wait '${label}': poll probe '${spec.probe}' is not registered in this run's WaitProbeRegistry`);
-	let polls = 0;
-	let probeErrors = 0;
-	for (;;) {
-		if (signal.aborted) return {
-			kind: "cancelled",
-			reason: "wait aborted"
-		};
-		polls += 1;
-		let fired = false;
-		try {
-			fired = await probe(spec.args, signal);
-		} catch {
-			probeErrors += 1;
-		}
-		if (fired) return {
-			kind: "woke",
-			outcome: outcome("poll", "fired", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
-		};
-		if (spec.timeoutAtMs !== void 0 && now() >= spec.timeoutAtMs) return {
-			kind: "woke",
-			outcome: outcome("poll", "timeout", label, spec.timeoutAtMs, armedAt, now(), polls, probeErrors, resumed)
-		};
-		await sleep(spec.timeoutAtMs === void 0 ? spec.intervalMs : Math.min(spec.intervalMs, Math.max(0, spec.timeoutAtMs - now())), signal);
-	}
-}
-function outcome(kind, settled, label, untilMs, armedAt, wokenAt, polls, probeErrors, resumed) {
-	return {
-		waitOutcome: true,
-		kind,
-		settled,
-		label,
-		...untilMs !== void 0 ? { untilMs } : {},
-		armedAt,
-		wokenAt,
-		polls,
-		probeErrors,
-		resumed
-	};
-}
-/** `setTimeout` that resolves early (and clears) when the scope aborts, so a cancelled wait
-*  releases the event loop immediately instead of holding the process to its deadline. */
-function defaultSleep$1(ms, signal) {
-	if (ms <= 0 || signal?.aborted) return Promise.resolve();
-	return sleep(ms, signal);
-}
-//#endregion
 //#region src/runtime/supervise/scope.ts
 /**
 *
@@ -24191,6 +23765,10 @@ const teardownRetriable = /* @__PURE__ */ new WeakMap();
 const ownerUnconfirmedByScope = /* @__PURE__ */ new WeakMap();
 /** The scope a recursive executor owns, so the settlement retry reaches its descendants. */
 const nestedTeardownScopes = /* @__PURE__ */ new WeakMap();
+/** Each scope's reader of the manager scopes its children own, read live. */
+const nestedManagerScopeReaders = /* @__PURE__ */ new WeakMap();
+/** A manager scope's release of its own environment, started once and joined by later callers. */
+const managerEnvironmentReleases = /* @__PURE__ */ new WeakMap();
 /** Scopes whose settlement released retained environments: none of their retained children is
 *  kept for a resume any longer. */
 const releasingScopes = /* @__PURE__ */ new WeakSet();
@@ -24268,9 +23846,47 @@ async function releaseRetainedEnvironments(scope) {
 	releasingScopes.add(scope);
 	const release = retainedReleasers.get(scope);
 	if (release) await release();
+	await releaseNestedManagerEnvironments(scope);
 	ownerUnconfirmedByScope.set(scope, await releaseScopeRetainedOwnerEnvironment(scope));
 	return unconfirmedTeardowns(scope);
 }
+/** The manager scopes this scope's children own, read live. */
+function nestedManagerScopes(scope) {
+	return nestedManagerScopeReaders.get(scope)?.() ?? [];
+}
+async function releaseNestedManagerEnvironments(scope) {
+	await Promise.all(nestedManagerScopes(scope).map(async (nested) => {
+		await releaseNestedManagerEnvironments(nested);
+		if (!ownerUnconfirmedByScope.has(nested)) await releaseManagerEnvironment(nested);
+	}));
+}
+/**
+* @internal Release the environment a manager kept between its turns, once its own scope has
+* finished and no turn of it will run again. The release first waits for the manager's last
+* end-of-turn capture, so it runs in the background of the manager's settlement; a later call,
+* including the run's settlement sweep, joins it. Its receipt is journaled in the manager's own
+* tree. It is the manager's own resource, not one of its descendants, so it never changes the
+* teardown answer its executor gives the parent.
+*/
+function releaseManagerEnvironment(scope) {
+	let release = managerEnvironmentReleases.get(scope);
+	if (release === void 0) {
+		release = releaseScopeRetainedOwnerEnvironment(scope).then(() => void 0);
+		managerEnvironmentReleases.set(scope, release);
+	}
+	return release;
+}
+/**
+* @internal Wait for the work every manager in this scope's tree still has in flight after its
+* node settled: the end-of-turn capture its last turn handed over, and the release of its
+* environment. The run's settlement awaits it under either retention policy, so nothing writes to
+* the run's journal after the run settles and no capture is cut short by the process exiting.
+*/
+async function settleManagerWork(scope) {
+	await Promise.all(nestedManagerScopes(scope).map((nested) => settleManagerWork(nested)));
+	await scopeRetainedOwnerSettled(scope);
+	await managerEnvironmentReleases.get(scope)?.catch(() => void 0);
+}
 /**
 * @internal Close the cursor slot of every retained child this scope and its nested scopes still
 * hold open, once the settlement is final and the release and its retries are done.
@@ -24441,13 +24057,11 @@ function createScope(args) {
 	} : void 0;
 	let spawnOrdinal = args.resumeFrom ? args.resumeFrom.maxSpawnOrdinal + 1 : 0;
 	let cursorSeq = args.resumeFrom ? args.resumeFrom.maxCursorSeq + 1 : 0;
-	let waitOrdinal = args.resumeFrom ? args.resumeFrom.maxWaitOrdinal + 1 : 0;
 	let meterSeq = 0;
 	let ownerTurns = 0;
 	let ownerLastTurnAt = 0;
 	let progressSeq = 0;
 	const now = args.now ?? Date.now;
-	const unclaimedWaits = new Map((args.resumeFrom?.waits ?? []).map((w) => [w.label, w]));
 	const keyed = /* @__PURE__ */ new Map();
 	for (const [key, prior] of args.resumeFrom?.keys ?? []) if (prior.state === "completed" && prior.settled?.kind === "done") {
 		if (prior.identity === void 0) continue;
@@ -24694,6 +24308,14 @@ function createScope(args) {
 				}, "accepted retained child result");
 				live.recoveryPending = false;
 			});
+			let captureSeq = 0;
+			const onWorkspaceCapture = workspaceCaptureWriter({
+				journal: args.journal,
+				rootId: args.root,
+				nodeId: id,
+				nextSequence: () => captureSeq++,
+				now
+			});
 			const onPause = (pause) => retainedWrite(async () => {
 				await args.journal.appendEvent(args.root, {
 					kind: "paused",
@@ -24722,6 +24344,7 @@ function createScope(args) {
 					now
 				}),
 				onPause,
+				onWorkspaceCapture,
 				continueInvocation: async (nextTask) => {
 					controller.signal.throwIfAborted();
 					if (live.acceptedResult === void 0) throw new ValidationError$1("scope: a retained child continues only after its invocation committed a result");
@@ -24838,7 +24461,7 @@ function createScope(args) {
 				abortChild: (reason) => controller.abort(reason)
 			};
 			const recordCancellation = () => {
-				if (!live.executorDone && live.acceptedResult === void 0 && controller.signal.reason instanceof RunCancellationReason) live.cancellationReason = controller.signal.reason;
+				if (!live.executorDone && live.acceptedResult === void 0 && executor.resultAccepted?.() !== true && controller.signal.reason instanceof RunCancellationReason) live.cancellationReason = controller.signal.reason;
 			};
 			if (controller.signal.aborted) recordCancellation();
 			else controller.signal.addEventListener("abort", recordCancellation, { once: true });
@@ -25109,165 +24732,6 @@ function createScope(args) {
 		child.lastActivityAt = now();
 		return true;
 	}
-	/**
-	* Arm a wait-state node. Deliberately NOT a `spawn` with a sleeping executor: it resolves no
-	* `AgentSpec`, constructs no `Executor`, and — the point of the whole mechanic — reserves NOTHING
-	* from the conserved pool, so a week-long wait costs zero tokens and zero dollars and cannot
-	* starve a worker of budget.
-	*
-	* Fail-closed admission, mirroring `spawn`'s typed outcome. The deadline check is the one that
-	* matters: a wait may not silently sleep past the pool's hard wall-clock ceiling, and it may not
-	* extend that ceiling either (that would make a wait override a budget guard).
-	*/
-	function wait(spec, opts) {
-		if (args.signal.aborted) return {
-			ok: false,
-			reason: "deadline-exceeded"
-		};
-		if (validateWaitSpec(spec) !== null) return {
-			ok: false,
-			reason: "invalid-spec"
-		};
-		if (spec.kind === "poll" && args.probes?.resolve(spec.probe) === void 0) return {
-			ok: false,
-			reason: "unknown-probe"
-		};
-		const adopted = unclaimedWaits.get(opts.label);
-		if (adopted) unclaimedWaits.delete(opts.label);
-		const effectiveSpec = adopted?.spec ?? spec;
-		const armedAt = adopted?.armedAt ?? now();
-		if (!assertWaitWithinDeadline(effectiveSpec, args.pool.readout().deadlineMs)) return {
-			ok: false,
-			reason: "deadline-exceeded"
-		};
-		const id = adopted ? adopted.id : `${args.parentId}:w${waitOrdinal}`;
-		const ordinal = adopted ? adopted.ordinal : waitOrdinal;
-		if (!adopted) waitOrdinal += 1;
-		const waitAbort = new AbortController();
-		const cascadeAbort = () => waitAbort.abort();
-		if (args.signal.aborted) waitAbort.abort();
-		else args.signal.addEventListener("abort", cascadeAbort, { once: true });
-		const handle = {
-			id,
-			label: opts.label,
-			get status() {
-				return children.get(id)?.status ?? "cancelled";
-			},
-			abort(reason) {
-				waitAbort.abort(reason);
-			}
-		};
-		const live = {
-			id,
-			status: "waiting",
-			runtime: "wait",
-			abortChild: (reason) => waitAbort.abort(reason),
-			budget: {
-				maxIterations: 0,
-				maxTokens: 0
-			},
-			label: opts.label,
-			spent: zeroSpend(),
-			settled: void 0,
-			delivered: false,
-			executorDone: false,
-			cleanupConfirmed: true,
-			teardownAttempts: 0,
-			executionBindings: [],
-			startedAt: armedAt,
-			lastActivityAt: now(),
-			wait: {
-				spec: effectiveSpec,
-				armedAt,
-				label: opts.label,
-				armCommitted: adopted !== void 0
-			}
-		};
-		children.set(id, live);
-		live.settled = (adopted ? Promise.resolve() : args.journal.appendEvent(args.root, {
-			kind: "waiting",
-			id,
-			parent: args.parentId,
-			label: opts.label,
-			spec: effectiveSpec,
-			armedAt,
-			seq: ordinal,
-			at: new Date(now()).toISOString()
-		})).then(() => {
-			if (live.wait) live.wait.armCommitted = true;
-			notifyRuntimeHookEvent(args.hooks, {
-				id: `${id}:waiting`,
-				runId: args.root,
-				target: "agent.spawn",
-				phase: "after",
-				timestamp: now(),
-				stepIndex: ordinal,
-				parentId: args.parentId,
-				payload: {
-					childId: id,
-					label: opts.label,
-					runtime: "wait",
-					wait: effectiveSpec,
-					armedAt,
-					resumed: adopted !== void 0
-				}
-			}, { signal: args.signal });
-			return runWait({
-				spec: effectiveSpec,
-				label: opts.label,
-				armedAt,
-				resumed: adopted !== void 0,
-				signal: waitAbort.signal,
-				...args.probes ? { probes: args.probes } : {},
-				now,
-				...args.waitSleep ? { sleep: args.waitSleep } : {}
-			});
-		}).then(async (resolution) => {
-			live.executorDone = true;
-			live.lastActivityAt = now();
-			if (resolution.kind === "cancelled") return {
-				kind: "down",
-				reason: resolution.reason,
-				infra: false,
-				trace: {
-					status: "unavailable",
-					reason: "not-an-executor"
-				}
-			};
-			const outRef = contentAddress(resolution.outcome);
-			await args.blobs.put(outRef, resolution.outcome);
-			return {
-				kind: "done",
-				out: resolution.outcome,
-				outRef,
-				spent: zeroSpend(),
-				trace: {
-					status: "unavailable",
-					reason: "not-an-executor"
-				}
-			};
-		}).catch((err) => {
-			live.executorDone = true;
-			return {
-				kind: "down",
-				reason: errMessage(err),
-				infra: true,
-				trace: {
-					status: "unavailable",
-					reason: "not-an-executor"
-				}
-			};
-		}).then((s) => {
-			live.resolved = s;
-			return s;
-		}).finally(() => {
-			args.signal.removeEventListener("abort", cascadeAbort);
-		});
-		return {
-			ok: true,
-			handle
-		};
-	}
 	function progress(nodeId, opts = {}) {
 		const child = children.get(nodeId);
 		if (!child) return void 0;
@@ -25317,7 +24781,7 @@ function createScope(args) {
 	function interactive(nodeId) {
 		const child = children.get(nodeId);
 		if (!child) return noInteractiveSession("unknown-node");
-		if (child.wait || child.executorDone || isTerminalNodeStatus(child.status)) return noInteractiveSession("not-live");
+		if (child.executorDone || isTerminalNodeStatus(child.status)) return noInteractiveSession("not-live");
 		const session = readInteractiveSession(child);
 		if (args.interactiveBindingDir !== void 0 && session.status === "available") writeWorkerInteractiveBinding(args.interactiveBindingDir, child.id, child.label, args.root, session, now);
 		return session;
@@ -25361,7 +24825,6 @@ function createScope(args) {
 	const resume = args.resumeFrom ? {
 		settled: args.resumeFrom.settled,
 		view: args.resumeFrom.view,
-		waits: args.resumeFrom.waits,
 		keys: args.resumeFrom.keys,
 		priorSpend: args.resumeFrom.priorSpend
 	} : void 0;
@@ -25370,7 +24833,6 @@ function createScope(args) {
 		next,
 		nextResolved,
 		send,
-		wait,
 		progress,
 		traceSource,
 		interactive,
@@ -25498,6 +24960,10 @@ function createScope(args) {
 		return child.ownedTreeRoot === void 0 || nested === void 0 || hasRetriableTeardowns(nested, true);
 	});
 	teardownRetriable.set(scope, (release) => retriableTeardowns().length > 0 || release && (releasable().length > 0 || retainedOwnerReleaseRetriable(scope)));
+	nestedManagerScopeReaders.set(scope, () => [...children.values()].flatMap((child) => {
+		const nested = child.readNestedScope?.();
+		return nested === void 0 ? [] : [nested];
+	}));
 	teardownRetriers.set(scope, async () => {
 		await Promise.all(retriableTeardowns().map((child) => {
 			child.teardownRetry ??= (async () => {
@@ -25684,6 +25150,15 @@ async function publishOwnerMaterialization(state, runtime, declaration, bindingI
 		state.publishedThisProcess = true;
 		return;
 	}
+	if (state.receipt !== void 0 && state.receipt.status !== "known") {
+		if (!state.bindingPublished) {
+			const boundToCommitted = knownExecutionBindingReceipt(state.receipt, bindingInput);
+			await appendOwnerBinding(state, boundToCommitted);
+			state.onReceipt?.(state.receipt, boundToCommitted);
+		}
+		state.publishedThisProcess = true;
+		return;
+	}
 	if (state.receipt !== void 0) {
 		if (canonicalCandidateDigest(state.receipt) !== canonicalCandidateDigest(receipt)) {
 			const changed = changedRunIdentityFields(state.receipt, receipt);
@@ -25951,7 +25426,6 @@ async function appendAcknowledged(journal, root, event) {
 *  `PreSeqSettled` into the frozen `Settled` the driver branches on. */
 async function finalizeSettlement(child, settlement, seq, args, now) {
 	const handle = frozenHandle(child);
-	if (child.wait) return finalizeWait(child, settlement, seq, args, now, handle);
 	const nestedScope = child.readNestedScope?.();
 	const subtree = nestedScope === void 0 ? void 0 : subtreeSummaryOf(nestedScope);
 	if (subtree !== void 0) child.subtree = subtree;
@@ -26072,68 +25546,6 @@ async function finalizeSettlement(child, settlement, seq, args, now) {
 		seq
 	};
 }
-/** Journal a wait-state's settlement as a `woken` event and project it onto the same `Settled`
-*  the driver branches on. `by` names WHY it woke — `fired` / `timeout` / `cancelled` — which is
-*  the fact a resumed reader needs and cannot recover from a payload it may never fetch. */
-async function finalizeWait(child, settlement, seq, args, now, handle) {
-	const settledAt = now();
-	child.settledAt = settledAt;
-	const at = new Date(settledAt).toISOString();
-	if (settlement.kind === "down") {
-		child.status = "cancelled";
-		if (child.wait?.armCommitted) await args.journal.appendEvent(args.root, {
-			kind: "woken",
-			id: child.id,
-			by: "cancelled",
-			seq,
-			at
-		});
-		return {
-			kind: "down",
-			handle,
-			reason: settlement.reason,
-			...settlement.infra === void 0 ? {} : { infra: settlement.infra },
-			trace: settlement.trace,
-			settledAt,
-			seq
-		};
-	}
-	child.status = "done";
-	child.outRef = settlement.outRef;
-	const out = settlement.out;
-	await args.journal.appendEvent(args.root, {
-		kind: "woken",
-		id: child.id,
-		by: out.settled,
-		outRef: settlement.outRef,
-		seq,
-		at
-	});
-	notifyRuntimeHookEvent(args.hooks, {
-		id: `${child.id}:woken`,
-		runId: args.root,
-		target: "agent.child",
-		phase: "after",
-		timestamp: settledAt,
-		stepIndex: seq,
-		parentId: args.parentId,
-		payload: {
-			childId: child.id,
-			status: "done",
-			wait: out
-		}
-	}, { signal: args.signal });
-	return {
-		kind: "done",
-		handle,
-		out: settlement.out,
-		outRef: settlement.outRef,
-		spent: settlement.spent,
-		trace: settlement.trace,
-		settledAt,
-		seq
-	};
-}
 /**
 * Drive one child's `Executor` to a terminal `PreSeqSettled`, folding usage into the
 * conserved `Spend`, reconciling the reservation, and persisting the result blob. Both
@@ -26261,7 +25673,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 			const reconcileError = reconcileOnce(accounting?.reservation ?? terminalSpend);
 			if (reconcileError !== void 0) throw reconcileError;
 		} else {
-			const terminal = await retainOutput(await awaitAbortable(Promise.resolve(ran), childAbort.signal));
+			const terminal = await retainOutput(await awaitUnlessAccepted(Promise.resolve(ran), childAbort.signal, executor));
 			await executionEvidence.complete();
 			const accounting = executor.accounting?.();
 			live.spent = accounting?.reported ?? terminal.spent;
@@ -26275,7 +25687,7 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 		const ownMetered = executor.metered?.();
 		const trace = await captureTraceOnce();
 		const childHarnessTranscript = await persistTranscriptOnce();
-		if (childAbort.signal.aborted && live.acceptedResult === void 0) {
+		if (childAbort.signal.aborted && live.acceptedResult === void 0 && executor.resultAccepted?.() !== true) {
 			await teardownOnce(opts.shutdown ?? "brutalKill");
 			return downRecord("aborted before settle", true, trace, ownMetered, runtimeOwnedExecutorProviderEvidence(executor), retainedOutputRef, childHarnessTranscript);
 		}
@@ -26410,8 +25822,6 @@ function settledToIteration(settled) {
 		tokenUsage: cloneTokenUsage(settled.spent.tokens)
 	};
 }
-/** Summarize one scope's children and everything below them, listing the best direct children
-*  and counting the rest. Wait-states are not agents and are left out. */
 /** The live team a child manager leads, read through the nested scope it owns. */
 function liveTeamOf(child) {
 	let nested;
@@ -26446,7 +25856,6 @@ function readLiveTeam(children, ownerTurns, ownerLastTurnAt) {
 	let down = 0;
 	let lastActivityAt = ownerLastTurnAt;
 	for (const child of children) {
-		if (child.wait) continue;
 		agents += 1;
 		lastActivityAt = Math.max(lastActivityAt, child.lastActivityAt, child.settledAt ?? 0, executorActivityAt(child));
 		if (child.status === "done") done += 1;
@@ -26484,7 +25893,6 @@ function summarizeTeam(children) {
 	let members = 0;
 	const results = [];
 	for (const child of children) {
-		if (child.wait) continue;
 		members += 1;
 		const below = child.subtree;
 		agents += 1 + (below?.agents ?? 0);
@@ -26544,8 +25952,7 @@ function makeTreeView(root, children) {
 	return {
 		root,
 		nodes,
-		inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring" || n.status === "queued").length,
-		waiting: nodes.filter((n) => n.status === "waiting").length
+		inFlight: nodes.filter((n) => n.status === "running" || n.status === "acquiring" || n.status === "queued").length
 	};
 }
 function frozenHandle(child) {
@@ -26667,6 +26074,19 @@ function preserveUnknownTelemetry(streamed, terminal) {
 		...(streamed.tokensProvenance ?? terminal.tokensProvenance) === void 0 ? {} : { tokensProvenance: streamed.tokensProvenance ?? terminal.tokensProvenance }
 	};
 }
+/**
+* Await a one-shot executor's terminal result unless an abort wins first, except for an execution
+* whose result was accepted before the abort arrived: it is ending the turn that submitted that
+* result, so it is awaited rather than discarded, and the executor bounds that wait itself.
+*/
+async function awaitUnlessAccepted(work, signal, executor) {
+	try {
+		return await awaitAbortable(work, signal);
+	} catch (error) {
+		if (signal.aborted && executor.resultAccepted?.() === true) return await work;
+		throw error;
+	}
+}
 async function awaitAbortable(work, signal) {
 	if (signal.aborted) {
 		work.catch(() => void 0);
@@ -26879,6 +26299,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 		...spec.progress ? { progress: spec.progress } : {},
 		...spec.harnessTranscript ? { harnessTranscript: spec.harnessTranscript } : {},
 		...spec.harnessTranscriptSettled ? { harnessTranscriptSettled: spec.harnessTranscriptSettled } : {},
+		resultAccepted: () => driver.resultAccepted?.() === true,
 		...deliver ? { deliver(message) {
 			return deliver(message) !== false;
 		} } : {},
@@ -26901,8 +26322,15 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 			if (recovering && (!spec.recoverExecutor || !seam.restore)) throw new RetainedExecutionPendingError(new ValidationError$1("driverExecutor: nested recovery has no original executor reconstruction"), "nested-recovery");
 			signal.throwIfAborted();
 			const controller = new AbortController();
-			const onParentAbort = () => controller.abort(signal.reason);
-			if (signal.aborted) controller.abort(signal.reason);
+			let clearAcceptedGrace;
+			const onParentAbort = () => {
+				if (driver.resultAccepted?.() === true) {
+					clearAcceptedGrace ??= armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, () => controller.abort(signal.reason));
+					return;
+				}
+				controller.abort(signal.reason);
+			};
+			if (signal.aborted) onParentAbort();
 			else signal.addEventListener("abort", onParentAbort, { once: true });
 			let nestedScope;
 			try {
@@ -26925,6 +26353,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				const out = await runAbortable(() => driver.act(task, nestedScope), controller.signal, "driver aborted");
 				await finalizeScopeOwnerMaterialization(nestedScope);
 				await closeActive("driver completed");
+				releaseManagerEnvironment(nestedScope).catch(() => void 0);
 				const events = await loadTreeEvents(journal, nestedRoot);
 				const childWork = sumSpend(events.filter(isSettled));
 				const totalMetered = sumMetered(events);
@@ -26955,6 +26384,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				throw err;
 			} finally {
 				signal.removeEventListener("abort", onParentAbort);
+				clearAcceptedGrace?.();
 				active = void 0;
 			}
 		},
@@ -27020,7 +26450,7 @@ async function closeNestedScope(scope, controller, reason) {
 	if (!controller.signal.aborted) controller.abort(reason);
 	for (;;) if (await scope.next() === null) break;
 	const view = scope.view;
-	if (view.inFlight > 0 || view.waiting > 0) throw new ValidationError$1(`driverExecutor: nested cleanup left ${view.inFlight} running and ${view.waiting} waiting nodes`);
+	if (view.inFlight > 0) throw new ValidationError$1(`driverExecutor: nested cleanup left ${view.inFlight} running nodes`);
 }
 /** The nested tree's full event list — the one evidence the spend, verdict, AND driver-inference
 *  roll-ups read off the same journal the supervisor sums. */
@@ -27953,7 +27383,7 @@ var DriverAttemptsExhaustedError = class extends RuntimeRunStateError {
 function summarizeDriverAttempts(records) {
 	let barren = 0;
 	for (const record of records) if (record.madeProgress) barren = 0;
-	else if (record.error === void 0 && record.reentry !== void 0 && record.contract === "unmet") barren += 1;
+	else if (record.error === void 0 && record.reentry !== void 0 && record.reentry !== "wake" && record.contract === "unmet") barren += 1;
 	const last = records.at(-1);
 	const refused = records.filter((record) => record.classification === "unavailable");
 	return {
@@ -27963,6 +27393,8 @@ function summarizeDriverAttempts(records) {
 		unavailablePauses: refused.filter((record) => record.retryInMs !== void 0).length,
 		unavailableMs: refused.reduce((sum, record) => sum + (record.madeProgress ? 0 : record.durationMs) + (record.retryInMs ?? 0), 0),
 		barrenReentries: barren,
+		wakes: records.filter((record) => record.reentry === "wake").length,
+		waitedMs: records.reduce((sum, record) => sum + (record.waitedMs ?? 0), 0),
 		ended: last?.stop ?? "unrecorded",
 		...last?.repromptRefusedBy === void 0 ? {} : { repromptRefusedBy: last.repromptRefusedBy }
 	};
@@ -28005,6 +27437,7 @@ async function runDriverWithRetry(run) {
 	let consecutivePauses = 0;
 	let pauses = 0;
 	let continuations = 0;
+	let wakes = 0;
 	let reentry;
 	const emit = async (record) => {
 		const entered = reentry === void 0 ? {} : { reentry: reentry.reason };
@@ -28164,7 +27597,28 @@ async function runDriverWithRetry(run) {
 		const contract = contractOf(after);
 		const contractField = contract === "none" ? {} : { contract };
 		if (progressed) barrenReentries = 0;
-		else if (reentry !== void 0 && contract === "unmet") barrenReentries += 1;
+		else if (reentry !== void 0 && reentry.reason !== "wake" && contract === "unmet") barrenReentries += 1;
+		const wait = run.wait;
+		if (wait !== void 0 && contract !== "met" && !(continuation?.closed() ?? false) && !run.signal.aborted && budgetStop(run.budget(), now()) === void 0 && wait.open()) {
+			const woken = await wait.wake(attempt + 1);
+			if (woken !== void 0 && !run.signal.aborted) {
+				wakes += 1;
+				await emit({
+					attempt,
+					durationMs,
+					madeProgress: progressed,
+					...contractField,
+					waitedMs: woken.idleMs,
+					retryInMs: 0
+				});
+				reentry = {
+					reason: "wake",
+					input: woken.input,
+					wake: wakes
+				};
+				continue;
+			}
+		}
 		if (contract === "unmet" && continuation !== void 0) {
 			const decision = await decideContinuation(continuation, attempt, after);
 			if ("steer" in decision) {
@@ -28544,7 +27998,7 @@ function describeRejection(error) {
 function createSupervisor() {
 	let attached;
 	async function run(root, task, opts) {
-		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, probes, maxDepth, workerSlots, reservationPolicy, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, ownerWorkspaceRetention, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
+		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, maxDepth, workerSlots, reservationPolicy, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, ownerWorkspaceRetention, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
 		const input = detachedSnapshot({
 			task,
 			options: {
@@ -28579,7 +28033,6 @@ function createSupervisor() {
 			blobs: persistence.blobs,
 			executors: executorRegistry,
 			...recoverExecutor ? { recoverExecutor } : {},
-			...probes === void 0 ? {} : { probes },
 			...suppliedNow === void 0 ? {} : { now: suppliedNow },
 			...signal === void 0 ? {} : { signal },
 			...hooks === void 0 ? {} : { hooks },
@@ -28590,6 +28043,7 @@ function createSupervisor() {
 		task = input.task;
 		const rootAct = root.act.bind(root);
 		const rootDeliver = root.deliver?.bind(root);
+		const rootResultAccepted = root.resultAccepted?.bind(root);
 		const now = opts.now ?? Date.now;
 		assertRootIdentity(opts);
 		const rootLease = attached?.acquire();
@@ -28696,7 +28150,6 @@ function createSupervisor() {
 					requiredKnown: true,
 					...priorRootMaterialization === void 0 ? {} : { prior: priorRootMaterialization }
 				} } : {},
-				...opts.probes ? { probes: opts.probes } : {},
 				...opts.workerTrace ? { workerTrace: opts.workerTrace } : {},
 				...opts.workerTraceUnpropagated ? { workerTraceUnpropagated: opts.workerTraceUnpropagated } : {},
 				...opts.interactiveBindingDir ? { interactiveBindingDir: opts.interactiveBindingDir } : {},
@@ -28711,10 +28164,19 @@ function createSupervisor() {
 			});
 			let deadlineExceeded = false;
 			const rootDeadlineAtMs = pool.readout().deadlineMs;
-			if (rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
-			const clearRootDeadline = opts.budget.deadlineMs === void 0 ? void 0 : armDeadlineTimer(Math.max(0, rootDeadlineAtMs - now()), () => {
+			let clearAcceptedGrace;
+			const reachRootDeadline = () => {
+				if (clearAcceptedGrace !== void 0) return;
+				if (rootResultAccepted?.() === true) {
+					clearAcceptedGrace = armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, () => {
+						deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
+					});
+					return;
+				}
 				deadlineExceeded = cascadeAbort(ROOT_DEADLINE_REASON);
-			});
+			};
+			if (rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) reachRootDeadline();
+			const clearRootDeadline = opts.budget.deadlineMs === void 0 ? void 0 : armDeadlineTimer(Math.max(0, rootDeadlineAtMs - now()), reachRootDeadline);
 			let actOutcome = {
 				ok: false,
 				error: new RuntimeRunStateError("supervisor: root execution did not start")
@@ -28741,9 +28203,11 @@ function createSupervisor() {
 				allChildrenDownAtSettle = allSpawnedChildrenDown(runTree(openScope));
 				if (!controller.signal.aborted && rootDeadlineAtMs > 0 && now() >= rootDeadlineAtMs) deadlineExceeded = true;
 				clearRootDeadline?.();
+				clearAcceptedGrace?.();
 				const settleGraceMs = !controller.signal.aborted ? boundedSettleGrace(opts.childSettleGraceMs, rootDeadlineAtMs, now) : 0;
 				try {
 					teardownUnconfirmed = await drainLiveChildren(openScope, controller, settleGraceMs);
+					await settleManagerWork(openScope);
 					if (!persistence.failed && retainedAtSettlement === "release") teardownUnconfirmed = await releaseRetainedEnvironments(openScope);
 					const confirmWindowMs = opts.teardownConfirmMs ?? DEFAULT_TEARDOWN_CONFIRM_MS;
 					const releasing = !persistence.failed && retainedAtSettlement === "release";
@@ -29036,8 +28500,7 @@ function wrapJournalForBreaker(journal, breaker) {
 * `allSettled`'d — a stray throw here is NOT the primary error (firstError precedence).
 */
 async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
-	const view = scope.view;
-	if (!(view.inFlight > 0 || view.waiting > 0)) {
+	if (scope.view.inFlight === 0) {
 		await drainCursor(scope);
 		return unconfirmedTeardowns(scope);
 	}
@@ -29050,7 +28513,7 @@ async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
 		clearGraceTimer?.();
 	}
 	const after = scope.view;
-	if (after.inFlight > 0 || after.waiting > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running, ${after.waiting} waiting, and ` + describeUnconfirmed(scope));
+	if (after.inFlight > 0) throw new RuntimeRunStateError(`supervisor: cleanup ended with ${after.inFlight} running and ` + describeUnconfirmed(scope));
 	return unconfirmedTeardowns(scope);
 }
 /** Five minutes: long enough to outlast a provider's transient delete failures and a slow
@@ -29315,6 +28778,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false || Object.values(s.resources ?? {}).some((resource) => resource.amount > 0 || !resource.known);
 }
 //#endregion
-export { bindScopeRetainedOwnerProvider as $, detachedFrozen as $i, parseWorkerToolTraceArtifact as $n, sanitizeRuntimeStreamEvent as $r, isPeerMailEnvelope as $t, driverExecutorFactory as A, addResourceSpend as Aa, prepareJsonlAppend as Ai, resolveAgentEnvironmentProvider as An, contentAddress as Ar, createExecutor as At, recordScopeOwnerDriverAttempt as B, promptFromAgentTurnInput as Ba, newExecutionAttemptId as Bi, InMemoryResultBlobStore as Bn, buildRuntimeEventOtelSpans as Br, workerTraceEnv as Bt, createContinuationKeeper as C, sleep as Ca, renderProfileMaterializationIssues as Ci, readPromptOptions as Cn, runAbortable as Cr, freeSlots as Ct, passedItems as D, unmeteredSpend as Da, validateProfileMaterialization as Di, createAgentEnvironmentProviderRegistry as Dn, readHarnessTranscript as Dr, captureReusableExecutorConfig as Dt, failedItems as E, throwIfAborted as Ea, unsupportedProfileDimensions as Ei, LEAF_CONTINUATION_TASK as En, persistHarnessTranscript as Er, bindReusableExecutorExecutionId as Et, beginScopeOwnerAttempt as F, awaitAbortable$1 as Fa, authoredProfileDigest as Fi, sandboxSessionTraceSource as Fn, defaultRedactor as Fr, createSteerableSandboxSession as Ft, settledToIteration as G, runtimeOwnedExecutorMaterialization as Gi, insideCursorNamespace as Gn, loopEventToOtelSpan as Gr, createActivityLog as Gt, recordScopeOwnerPause as H, providerMessageText as Ha, recordRuntimeOwnedDriveHarnessProviderEvidence as Hi, SpawnEventIndex as Hn, createOtelExporter as Hr, workerTraceSeamKey as Ht, createScope as I, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ia, finalizeRuntimeOwnedPendingExecutor as Ii, registerRetainedExecutorPreparation as In, defaultRedactorIdentityMaterial as Ir, createRouterTranscript as It, pollFor as J, runtimeOwnedScopeOwnerRuntime as Ji, pendingWaits as Jn, toOtelAttributes as Jr, AUTHORITY_MARKERS as Jt, createWaitProbes as K, runtimeOwnedExecutorProviderEvidence as Ki, loadSpawnForest as Kn, padSpanId as Kr, readWorkerProgress as Kt, deriveNodeExecutionIdentity as L, armDeadlineTimer as La, inheritRuntimeOwnedExecutorAttestation as Li, retainedExecutorSeamKey as Ln, resolveRedactor as Lr, createInPlaceCliExecutor as Lt, withDriverExecutor as M, withBudgetResources as Ma, writeAllBytes as Mi, unavailableSignalOfFailure as Mn, mergeTraceEnv as Mr, snapshotExecutorConfig as Mt, SUBTREE_RESULT_LIMIT as N, decodeHarnessUsage as Na, attestRuntimeOwnedPendingExecutor as Ni, createPushTraceSource as Nn, readTraceContextFromEnv as Nr, createWorktreeCliExecutor as Nt, verdictFromJudgeScore as O, withTimeout as Oa, worktreeCliProfileMaterialization as Oi, providerAsExecutor as On, resolveHarnessTranscriptCapture as Or, cliInPlaceExecutor as Ot, assertRecursiveReservationPolicy as P, abortError$2 as Pa, attestRuntimeOwnedScopeOwner as Pi, decodeToolPart as Pn, traceContextToEnv as Pr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Pt, bindScopeRetainedOwnerEnvironmentId as Q, executableAgentSpecSnapshot as Qi, isTraceAnalysisStore as Qn, sanitizeKnowledgeReadinessReport as Qr, createPeerMailbox as Qt, meterRuntimeOwnedAccounting as R, teardownExecutor as Ra, knownExecutionBindingReceipt as Ri, FileResultBlobStore as Rn, buildLoopOtelSpans as Rr, WORKER_TRACE_PROPAGATION as Rt, composeContinuationNote as S, randomSuffix as Sa, promptResourceProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, linkAbort as Sr, startRetainedInteractiveRun as St, expandQuestions as T, throwAbort as Ta, sandboxActProfileMaterialization as Ti, runBrainLoop as Tn, harnessTranscriptArtifact as Tr, rollingDispatch as Tt, restoreScopeOwnerAcceptedExecution as U, runtimeOwnedDriveHarnessProviderEvidence as Ui, assertContentAddress as Un, flatOtelSpan as Ur, taskToPrompt as Ut, recordScopeOwnerMaterialization as V, promptOptionsFromAgentTurnInput as Va, providerAttemptEvidence as Vi, InMemorySpawnJournal as Vn, createOpenInferenceFileExporter as Vr, workerTraceHeaders as Vt, scopeOwnerExecutorNodeContext as W, runtimeOwnedExecutorExecutionBinding as Wi, encodeResultBlob as Wn, generateSpanId as Wr, DEFAULT_STALL_AFTER_MS as Wt, validateWaitSpec as X, unknownMaterializationReceipt as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, createRuntimeStreamEventCollector as Xr, PEER_MAIL_WIRE_KEY as Xt, timerAt as Y, unknownExecutionBindingReceipt as Yi, replaySpawnTree as Yn, createRuntimeEventCollector as Yr, DEFAULT_PEER_MAIL_LIMITS as Yt, waitUntil as Z, executableAgentProfileSnapshot as Zi, captureWorkerTraceEvidence as Zn, sanitizeAgentRuntimeEvent as Zr, claimsAuthority as Zt, CheckUnavailableError as _, cloneSpend as _a, fullProfileMaterialization as _i, createSandboxLineage as _n, environmentGone as _r, readWorkerInteractiveBinding as _t, collectDelivered as a, createSandboxToolPartState as aa, DEFAULT_LOCAL_HARNESS as ai, bridgeModelRouteRefusal as an, createBudgetPool as ar, scopeRetainedOwnerPriorSpend as at, bestComposite as b, isAbortError$2 as ba, promptModelProfileMaterialization as bi, SandboxEvidenceRetentionError as bn, RunCancellationReason as br, reconnectRetainedInteractiveRun as bt, runTree as c, isSandboxTerminalEvent as ca, harnessSupportsReasoningEffort as ci, harnessUsageIsEmpty as cn, spendFromUsageEvents as cr, scopeRetainedOwnerResult as ct, classifyDriverFailure as d, notifySandboxEventObserver as da, CodexExecutionDiagnosticError as di, bridgeStopSignalKey as dn, reconnectRetainedRun as dr, hostDirectoryReader as dt, detachedSnapshot as ea, runSettledCommand as ei, peerMailTools as en, workerTraceAnalysisStore as er, consumeScopeRetainedOwnerResult as et, runDriverWithRetry as f, sandboxEventServedBackend as fa, terminateProcessTreeAndConfirm as fi, TERMINAL_DECISIONS as fn, recoverRetainedRun as fr, resolveSpawnResourcePaths as ft, CONTINUATION_FACTS as g, chargedTokens as ga, defineProfileMaterializationContract as gi, runAgentRounds as gn, destroyInteractiveEnvironment as gr, attachWorker as gt, CONTINUATIONS_DIR as h, addSpend as ha, controlProfileMaterialization as hi, isTerminalDecision as hn, retainedCreateMaterial as hr, workerInteractiveAdmissionFile as ht, bestDelivered as i, canonicalStreamEventFromSandboxEvent as ia, removeWorktree as ii, bridgeAdmissionRefusal as in, assertValidBudget as ir, scopeRetainedOwnerContext as it, isDriverSpec as j, resourceTelemetry as ja, readCommittedJsonLines as ji, unavailablePauseMs as jn, createPropagatingTraceEmitter as jr, createExecutorRegistry as jt, driverChild as k, zeroSpend as ka, isNoEntError as ki, providerAsSandboxClient as kn, retainHarnessTranscript as kr, cliWorktreeExecutor as kt, DriverAttemptsExhaustedError as l, mapSandboxEvent as la, localHarnessExecutable as li, readCodexRolloutSession as ln, spendFromUsageTotals as lr, SPAWN_RESOURCE_PATH_MAX_BYTES as lt, upstreamUnavailableSignal as m, sumSandboxUsage as ma, assertProfileMaterialization as mi, defaultSelectWinner as mn, startRetainedRunInEnvironment as mr, readWorkerInteractiveAdmissions as mt, createRootHandle as n, readSandboxOutcome as na, captureWorktreeDiff as ni, isLiveNodeStatus as nn, BudgetReconcileFault as nr, prepareScopeRetainedOwnerTask as nt, pickBestDelivered as o, createSandboxUsageLedger as oa, LOCAL_HARNESSES as oi, addHarnessUsage as on, meterUsageEvent as or, scopeRetainedOwnerResourceReader as ot, summarizeDriverAttempts as p, sandboxProgressEvents as pa, AGENT_PROFILE_MATERIALIZATION_AXES as pi, createSandboxForSpec as pn, startRetainedRun as pr, interactiveAdmissionSeamKey as pt, isWaitOutcome as q, runtimeOwnedPendingExecutorMaterialization as qi, materializeTreeView as qn, padTraceId as qr, createInbox as qt, createSupervisor as r, assertSandboxServedModel as ra, createWorktree as ri, isTerminalNodeStatus as rn, ReservationWaitRefused as rr, reconcileScopeRetainedOwnerEnvironment as rt, runFinalizer as s, extractLlmCallEvent as sa, harnessInvocation as si, createCodexRolloutStoreReader as sn, newUsageTotals as sr, scopeRetainedOwnerRestorePoint as st, DEFAULT_MAX_DEPTH as t, projectSandboxOutcome as ta, runWorktreeHarness as ti, peerMailVerbNames as tn, executorFailure as tr, noteScopeRetainedOwnerCoordination as tt, HarnessTurnFailedError as u, mapSandboxToolEvent as ua, parseCodexTokenUsage as ui, bridgeRuntimeAttachmentsKey as un, errMessage as ur, environmentReader as ut, admitContinuationPolicy as v, deleteBoxSafe as va, profileMaterializationAxes$1 as vi, probeSandboxCapabilities as vn, createWorkerSlots as vr, workerInteractiveBindingFile as vt, distillFindings as w, stringifySafe as wa, renderUnsupported as wi, routerBrain as wn, captureHarnessTranscript as wr, queueOf as wt, checkVerdictOf as x, promptCacheTokenClasses as xa, promptOnlyProfileMaterialization as xi, captureBeforeDestroy as xn, abortError as xr, recoverRetainedInteractiveRun as xt, admitFinding as y, hasCompleteCacheBreakdown as ya, promptControlProfileMaterialization as yi, acquireSandbox as yn, openSlotGroup as yr, workerInteractiveBindingsDir as yt, meterRuntimeOwnedProviderAttempt as z, teardownSurfaces as za, knownMaterializationReceipt as zi, FileSpawnJournal as zn, buildLoopSpanNodes as zr, readWorkerTraceContext as zt };
+export { scopeRetainedOwnerPriorSpend as $, sandboxProgressEvents as $i, bridgeStopSignalKey as $n, localHarnessExecutable as $r, harnessUsageIsEmpty as $t, isDriverSpec as A, runtimeOwnedExecutorExecutionBinding as Ai, insideCursorNamespace as An, buildRuntimeEventOtelSpans as Ar, readWorkerTraceContext as At, recordScopeOwnerMaterialization as B, detachedSnapshot as Bi, isTraceAnalysisStore as Bn, createRuntimeStreamEventCollector as Br, DEFAULT_PEER_MAIL_LIMITS as Bt, distillFindings as C, inheritRuntimeOwnedExecutorAttestation as Ci, sandboxSessionTraceSource as Cn, readTraceContextFromEnv as Cr, snapshotExecutorConfig as Ct, verdictFromJudgeScore as D, providerAttemptEvidence as Di, FileSpawnJournal as Dn, resolveRedactor as Dr, createRouterTranscript as Dt, passedItems as E, newExecutionAttemptId as Ei, FileResultBlobStore as En, defaultRedactorIdentityMaterial as Er, createSteerableSandboxSession as Et, createScope as F, unknownExecutionBindingReceipt as Fi, prepareJsonlAppend as Fn, loopEventToOtelSpan as Fr, DEFAULT_STALL_AFTER_MS as Ft, beginScopeRetainedOwnerDrive as G, createSandboxToolPartState as Gi, ReservationWaitRefused as Gn, runWorktreeHarness as Gr, peerMailTools as Gt, restoreScopeOwnerAcceptedExecution as H, readSandboxOutcome as Hi, workerTraceAnalysisStore as Hn, sanitizeKnowledgeReadinessReport as Hr, claimsAuthority as Ht, deriveNodeExecutionIdentity as I, unknownMaterializationReceipt as Ii, readCommittedJsonLines as In, padSpanId as Ir, createActivityLog as It, consumeScopeRetainedOwnerResult as J, isSandboxTerminalEvent as Ji, meterUsageEvent as Jn, removeWorktree as Jr, isTerminalNodeStatus as Jt, bindScopeRetainedOwnerEnvironmentId as K, createSandboxUsageLedger as Ki, assertValidBudget as Kn, captureWorktreeDiff as Kr, peerMailVerbNames as Kt, meterRuntimeOwnedAccounting as L, executableAgentProfileSnapshot as Li, writeAllBytes as Ln, padTraceId as Lr, readWorkerProgress as Lt, SUBTREE_RESULT_LIMIT as M, runtimeOwnedExecutorProviderEvidence as Mi, materializeTreeView as Mn, createOtelExporter as Mr, workerTraceHeaders as Mt, assertRecursiveReservationPolicy as N, runtimeOwnedPendingExecutorMaterialization as Ni, replaySpawnTree as Nn, flatOtelSpan as Nr, workerTraceSeamKey as Nt, driverChild as O, recordRuntimeOwnedDriveHarnessProviderEvidence as Oi, InMemoryResultBlobStore as On, buildLoopOtelSpans as Or, createInPlaceCliExecutor as Ot, beginScopeOwnerAttempt as P, runtimeOwnedScopeOwnerRuntime as Pi, isNoEntError as Pn, generateSpanId as Pr, taskToPrompt as Pt, scopeRetainedOwnerContext as Q, sandboxEventServedBackend as Qi, bridgeRuntimeAttachmentsKey as Qn, harnessSupportsReasoningEffort as Qr, createCodexRolloutStoreReader as Qt, meterRuntimeOwnedProviderAttempt as R, executableAgentSpecSnapshot as Ri, WORKER_TOOL_TRACE_SCHEMA_VERSION as Rn, toOtelAttributes as Rr, createInbox as Rt, createContinuationKeeper as S, finalizeRuntimeOwnedPendingExecutor as Si, decodeToolPart as Sn, mergeTraceEnv as Sr, createExecutorRegistry as St, failedItems as T, knownMaterializationReceipt as Ti, retainedExecutorSeamKey as Tn, defaultRedactor as Tr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Tt, scopeOwnerExecutorNodeContext as U, assertSandboxServedModel as Ui, executorFailure as Un, sanitizeRuntimeStreamEvent as Ur, createPeerMailbox as Ut, recordScopeOwnerPause as V, projectSandboxOutcome as Vi, parseWorkerToolTraceArtifact as Vn, sanitizeAgentRuntimeEvent as Vr, PEER_MAIL_WIRE_KEY as Vt, settledToIteration as W, canonicalStreamEventFromSandboxEvent as Wi, BudgetReconcileFault as Wn, runSettledCommand as Wr, isPeerMailEnvelope as Wt, prepareScopeRetainedOwnerTask as X, mapSandboxToolEvent as Xi, spendFromUsageEvents as Xn, LOCAL_HARNESSES as Xr, bridgeModelRouteRefusal as Xt, noteScopeRetainedOwnerCoordination as Y, mapSandboxEvent as Yi, newUsageTotals as Yn, DEFAULT_LOCAL_HARNESS as Yr, bridgeAdmissionRefusal as Yt, reconcileScopeRetainedOwnerEnvironment as Z, notifySandboxEventObserver as Zi, spendFromUsageTotals as Zn, harnessInvocation as Zr, addHarnessUsage as Zt, CheckUnavailableError as _, validateProfileMaterialization as _i, providerAsSandboxClient as _n, readHarnessTranscript as _r, bindReusableExecutorExecutionId as _t, collectDelivered as a, promptOptionsFromAgentTurnInput as aa, controlProfileMaterialization as ai, runAgentRounds as an, retainedCreateMaterial as ar, environmentReader as at, bestComposite as b, attestRuntimeOwnedScopeOwner as bi, unavailableSignalOfFailure as bn, contentAddress as br, cliWorktreeExecutor as bt, runTree as c, profileMaterializationAxes$1 as ci, SandboxEvidenceRetentionError as cn, createWorkerSlots as cr, interactiveAdmissionSeamKey as ct, classifyDriverFailure as d, promptOnlyProfileMaterialization as di, readPromptOptions as dn, abortError as dr, reconnectRetainedInteractiveRun as dt, sumSandboxUsage as ea, parseCodexTokenUsage as ei, readCodexRolloutSession as en, errMessage as er, scopeRetainedOwnerResourceReader as et, runDriverWithRetry as f, promptResourceProfileMaterialization as fi, routerBrain as fn, linkAbort as fr, recoverRetainedInteractiveRun as ft, CONTINUATION_FACTS as g, unsupportedProfileDimensions as gi, providerAsExecutor as gn, persistHarnessTranscript as gr, rollingDispatch as gt, CONTINUATIONS_DIR as h, sandboxActProfileMaterialization as hi, createAgentEnvironmentProviderRegistry as hn, harnessTranscriptArtifact as hr, queueOf as ht, bestDelivered as i, promptFromAgentTurnInput as ia, assertProfileMaterialization as ii, isTerminalDecision as in, startRetainedRunInEnvironment as ir, SPAWN_RESOURCE_PATH_MAX_BYTES as it, withDriverExecutor as j, runtimeOwnedExecutorMaterialization as ji, loadSpawnForest as jn, createOpenInferenceFileExporter as jr, workerTraceEnv as jt, driverExecutorFactory as k, runtimeOwnedDriveHarnessProviderEvidence as ki, InMemorySpawnJournal as kn, buildLoopSpanNodes as kr, WORKER_TRACE_PROPAGATION as kt, DriverAttemptsExhaustedError as l, promptControlProfileMaterialization as li, captureBeforeDestroy as ln, openSlotGroup as lr, attachWorker as lt, upstreamUnavailableSignal as m, renderUnsupported as mi, LEAF_CONTINUATION_TASK as mn, captureHarnessTranscript as mr, freeSlots as mt, createRootHandle as n, abortError$1 as na, terminateProcessTreeAndConfirm as ni, createSandboxForSpec as nn, recoverRetainedRun as nr, scopeRetainedOwnerResult as nt, pickBestDelivered as o, providerMessageText as oa, defineProfileMaterializationContract as oi, createSandboxLineage as on, destroyInteractiveEnvironment as or, hostDirectoryReader as ot, summarizeDriverAttempts as p, renderProfileMaterializationIssues as pi, runBrainLoop as pn, runAbortable as pr, startRetainedInteractiveRun as pt, bindScopeRetainedOwnerProvider as q, extractLlmCallEvent as qi, createBudgetPool as qn, createWorktree as qr, isLiveNodeStatus as qt, createSupervisor as r, awaitAbortable$1 as ra, AGENT_PROFILE_MATERIALIZATION_AXES as ri, defaultSelectWinner as rn, startRetainedRun as rr, scopeRetainedOwnerTurnEnded as rt, runFinalizer as s, fullProfileMaterialization as si, acquireSandbox as sn, environmentGone as sr, resolveSpawnResourcePaths as st, DEFAULT_MAX_DEPTH as t, decodeHarnessUsage as ta, CodexExecutionDiagnosticError as ti, TERMINAL_DECISIONS as tn, reconnectRetainedRun as tr, scopeRetainedOwnerRestorePoint as tt, HarnessTurnFailedError as u, promptModelProfileMaterialization as ui, assertBoxlessPromptOptions as un, RunCancellationReason as ur, readWorkerInteractiveBinding as ut, admitContinuationPolicy as v, worktreeCliProfileMaterialization as vi, resolveAgentEnvironmentProvider as vn, resolveHarnessTranscriptCapture as vr, captureReusableExecutorConfig as vt, expandQuestions as w, knownExecutionBindingReceipt as wi, registerRetainedExecutorPreparation as wn, traceContextToEnv as wr, createWorktreeCliExecutor as wt, checkVerdictOf as x, authoredProfileDigest as xi, createPushTraceSource as xn, createPropagatingTraceEmitter as xr, createExecutor as xt, admitFinding as y, attestRuntimeOwnedPendingExecutor as yi, unavailablePauseMs as yn, retainHarnessTranscript as yr, cliInPlaceExecutor as yt, recordScopeOwnerDriverAttempt as z, detachedFrozen as zi, captureWorkerTraceEvidence as zn, createRuntimeEventCollector as zr, AUTHORITY_MARKERS as zt };
 
-//# sourceMappingURL=supervisor-CQSu5XGl.js.map
+//# sourceMappingURL=supervisor-gCfG6K1-.js.map