@tangle-network/agent-runtime 0.301.0 → 0.306.2

package/dist/{supervisor-DA_nvF-h.js → supervisor-DYKPbcZa.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-DaQceg2p.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,130 +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";
-/**
-* How long an abort waits for a manager whose result was already accepted to end the turn that
-* submitted it. Acceptance asks the turn's harness to stop; what remains is the turn's final
-* session copy (a bounded native capture), metering its usage and committing its result. Its
-* workspace capture is not part of it: the manager's owner runs that after the result.
-*/
-const ACCEPTED_RESULT_GRACE_MS = 5 * 6e4;
-/** 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");
@@ -322,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;
@@ -332,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 });
@@ -389,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;
@@ -426,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() {
@@ -436,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 });
 	});
@@ -661,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",
@@ -2502,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);
 /**
@@ -7321,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`);
@@ -7328,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`);
@@ -7592,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) => {
@@ -7603,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) => {
@@ -7623,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;
@@ -7635,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) => {
@@ -7770,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);
@@ -7821,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();
@@ -8054,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";
@@ -8419,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,
@@ -8459,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)
 	};
 }
@@ -9571,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
@@ -9696,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
@@ -10341,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",
@@ -10368,6 +9812,9 @@ 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",
@@ -10409,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);
@@ -10432,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;
@@ -10445,6 +9891,9 @@ 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;
@@ -10454,39 +9903,6 @@ async function replaySpawnTree(journal, blobs, root) {
 		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",
@@ -10586,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,
@@ -10631,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";
@@ -10682,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 {};
@@ -11234,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;
@@ -14606,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;
@@ -14699,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 ?? (() => {});
@@ -14795,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 {
@@ -14858,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;
@@ -14880,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
@@ -15151,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,
@@ -15798,12 +15091,7 @@ function hashJson(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");
+	return fnv1a32Hex(str);
 }
 //#endregion
 //#region src/runtime/sandbox-executor-output.ts
@@ -17308,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;
@@ -17326,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",
@@ -19309,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
 		});
@@ -21061,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
@@ -21875,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");
@@ -22307,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.
 *
@@ -22986,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)
 		}
@@ -23424,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) {
@@ -23602,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) {
@@ -23695,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,
@@ -23712,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 {}
@@ -23723,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
@@ -23860,19 +23318,23 @@ async function releaseOwnerEnvironment(state, provider) {
 	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 {
@@ -23928,19 +23390,36 @@ async function releaseOwnerEnvironment(state, provider) {
 		});
 	}
 	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, 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})`
-	}))];
+	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",
@@ -24245,179 +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 a manager's wake (`./wake`) ──
-*
-* They look similar and are not the same mechanism. A wake is an IN-RUN RENDEZVOUS: a manager
-* that ends its turn with work open is resumed when the coordination bus delivers its next event.
-* It costs no model turn, but it lives in 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
 /**
 *
@@ -24751,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;
@@ -25428,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;
@@ -25636,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;
@@ -25680,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;
@@ -25689,7 +24833,6 @@ function createScope(args) {
 		next,
 		nextResolved,
 		send,
-		wait,
 		progress,
 		traceSource,
 		interactive,
@@ -26007,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);
@@ -26274,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;
@@ -26395,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
@@ -26733,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;
@@ -26769,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;
@@ -26807,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);
@@ -26867,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) {
@@ -27366,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. */
@@ -28914,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: {
@@ -28949,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 },
@@ -29067,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 } : {},
@@ -29418,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);
 	}
@@ -29432,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
@@ -29697,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 { bindScopeRetainedOwnerEnvironmentId as $, executableAgentProfileSnapshot as $i, parseWorkerToolTraceArtifact as $n, sanitizeAgentRuntimeEvent as $r, claimsAuthority as $t, driverExecutorFactory as A, withTimeout as Aa, worktreeCliProfileMaterialization as Ai, resolveAgentEnvironmentProvider as An, resolveHarnessTranscriptCapture as Ar, cliInPlaceExecutor as At, recordScopeOwnerDriverAttempt as B, teardownExecutor as Ba, knownExecutionBindingReceipt as Bi, InMemoryResultBlobStore as Bn, buildLoopOtelSpans as Br, WORKER_TRACE_PROPAGATION as Bt, createContinuationKeeper as C, promptCacheTokenClasses as Ca, promptOnlyProfileMaterialization as Ci, readPromptOptions as Cn, abortError as Cr, recoverRetainedInteractiveRun as Ct, passedItems as D, throwAbort as Da, sandboxActProfileMaterialization as Di, createAgentEnvironmentProviderRegistry as Dn, harnessTranscriptArtifact as Dr, rollingDispatch as Dt, failedItems as E, stringifySafe as Ea, renderUnsupported as Ei, LEAF_CONTINUATION_TASK as En, captureHarnessTranscript as Er, queueOf as Et, beginScopeOwnerAttempt as F, decodeHarnessUsage as Fa, attestRuntimeOwnedPendingExecutor as Fi, sandboxSessionTraceSource as Fn, readTraceContextFromEnv as Fr, createWorktreeCliExecutor as Ft, settledToIteration as G, runtimeOwnedDriveHarnessProviderEvidence as Gi, insideCursorNamespace as Gn, flatOtelSpan as Gr, taskToPrompt as Gt, recordScopeOwnerPause as H, promptFromAgentTurnInput as Ha, newExecutionAttemptId as Hi, SpawnEventIndex as Hn, buildRuntimeEventOtelSpans as Hr, workerTraceEnv as Ht, createScope as I, abortError$2 as Ia, attestRuntimeOwnedScopeOwner as Ii, registerRetainedExecutorPreparation as In, traceContextToEnv as Ir, DEFAULT_SANDBOX_STEERING_MAX_TURNS as It, pollFor as J, runtimeOwnedExecutorProviderEvidence as Ji, pendingWaits as Jn, padSpanId as Jr, readWorkerProgress as Jt, createWaitProbes as K, runtimeOwnedExecutorExecutionBinding as Ki, loadSpawnForest as Kn, generateSpanId as Kr, DEFAULT_STALL_AFTER_MS as Kt, deriveNodeExecutionIdentity as L, awaitAbortable$1 as La, authoredProfileDigest as Li, retainedExecutorSeamKey as Ln, defaultRedactor as Lr, createSteerableSandboxSession as Lt, withDriverExecutor as M, addResourceSpend as Ma, prepareJsonlAppend as Mi, unavailableSignalOfFailure as Mn, contentAddress as Mr, createExecutor as Mt, SUBTREE_RESULT_LIMIT as N, resourceTelemetry as Na, readCommittedJsonLines as Ni, createPushTraceSource as Nn, createPropagatingTraceEmitter as Nr, createExecutorRegistry as Nt, verdictFromJudgeScore as O, throwIfAborted as Oa, unsupportedProfileDimensions as Oi, providerAsExecutor as On, persistHarnessTranscript as Or, bindReusableExecutorExecutionId as Ot, assertRecursiveReservationPolicy as P, withBudgetResources as Pa, writeAllBytes as Pi, decodeToolPart as Pn, mergeTraceEnv as Pr, snapshotExecutorConfig as Pt, beginScopeRetainedOwnerDrive as Q, unknownMaterializationReceipt as Qi, isTraceAnalysisStore as Qn, createRuntimeStreamEventCollector as Qr, PEER_MAIL_WIRE_KEY as Qt, meterRuntimeOwnedAccounting as R, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Ra, finalizeRuntimeOwnedPendingExecutor as Ri, FileResultBlobStore as Rn, defaultRedactorIdentityMaterial as Rr, createRouterTranscript as Rt, composeContinuationNote as S, isAbortError$2 as Sa, promptModelProfileMaterialization as Si, assertBoxlessPromptOptions as Sn, RunCancellationReason as Sr, reconnectRetainedInteractiveRun as St, expandQuestions as T, sleep as Ta, renderProfileMaterializationIssues as Ti, runBrainLoop as Tn, runAbortable as Tr, freeSlots as Tt, restoreScopeOwnerAcceptedExecution as U, promptOptionsFromAgentTurnInput as Ua, providerAttemptEvidence as Ui, assertContentAddress as Un, createOpenInferenceFileExporter as Ur, workerTraceHeaders as Ut, recordScopeOwnerMaterialization as V, teardownSurfaces as Va, knownMaterializationReceipt as Vi, InMemorySpawnJournal as Vn, buildLoopSpanNodes as Vr, readWorkerTraceContext as Vt, scopeOwnerExecutorNodeContext as W, providerMessageText as Wa, recordRuntimeOwnedDriveHarnessProviderEvidence as Wi, encodeResultBlob as Wn, createOtelExporter as Wr, workerTraceSeamKey as Wt, validateWaitSpec as X, runtimeOwnedScopeOwnerRuntime as Xi, WORKER_TOOL_TRACE_SCHEMA_VERSION as Xn, toOtelAttributes as Xr, AUTHORITY_MARKERS as Xt, timerAt as Y, runtimeOwnedPendingExecutorMaterialization as Yi, replaySpawnTree as Yn, padTraceId as Yr, createInbox as Yt, waitUntil as Z, unknownExecutionBindingReceipt as Zi, captureWorkerTraceEvidence as Zn, createRuntimeEventCollector as Zr, DEFAULT_PEER_MAIL_LIMITS as Zt, CheckUnavailableError as _, addSpend as _a, controlProfileMaterialization as _i, createSandboxLineage as _n, retainedCreateMaterial as _r, workerInteractiveAdmissionFile as _t, collectDelivered as a, assertSandboxServedModel as aa, createWorktree as ai, isTerminalNodeStatus as an, createBudgetPool as ar, scopeRetainedOwnerContext as at, bestComposite as b, deleteBoxSafe as ba, profileMaterializationAxes$1 as bi, SandboxEvidenceRetentionError as bn, createWorkerSlots as br, workerInteractiveBindingFile as bt, runTree as c, createSandboxUsageLedger as ca, LOCAL_HARNESSES as ci, addHarnessUsage as cn, spendFromUsageEvents as cr, scopeRetainedOwnerRestorePoint as ct, classifyDriverFailure as d, mapSandboxEvent as da, localHarnessExecutable as di, readCodexRolloutSession as dn, bridgeStopSignalKey as dr, SPAWN_RESOURCE_PATH_MAX_BYTES as dt, executableAgentSpecSnapshot as ea, sanitizeKnowledgeReadinessReport as ei, createPeerMailbox as en, workerTraceAnalysisStore as er, bindScopeRetainedOwnerProvider as et, runDriverWithRetry as f, mapSandboxToolEvent as fa, parseCodexTokenUsage as fi, TERMINAL_DECISIONS as fn, errMessage as fr, environmentReader as ft, CONTINUATION_FACTS as g, sumSandboxUsage as ga, assertProfileMaterialization as gi, runAgentRounds as gn, startRetainedRunInEnvironment as gr, readWorkerInteractiveAdmissions as gt, CONTINUATIONS_DIR as h, sandboxProgressEvents as ha, AGENT_PROFILE_MATERIALIZATION_AXES as hi, isTerminalDecision as hn, startRetainedRun as hr, interactiveAdmissionSeamKey as ht, bestDelivered as i, readSandboxOutcome as ia, captureWorktreeDiff as ii, isLiveNodeStatus as in, assertValidBudget as ir, reconcileScopeRetainedOwnerEnvironment as it, isDriverSpec as j, zeroSpend as ja, isNoEntError as ji, unavailablePauseMs as jn, retainHarnessTranscript as jr, cliWorktreeExecutor as jt, driverChild as k, unmeteredSpend as ka, validateProfileMaterialization as ki, providerAsSandboxClient as kn, readHarnessTranscript as kr, captureReusableExecutorConfig as kt, DriverAttemptsExhaustedError as l, extractLlmCallEvent as la, harnessInvocation as li, createCodexRolloutStoreReader as ln, spendFromUsageTotals as lr, scopeRetainedOwnerResult as lt, upstreamUnavailableSignal as m, sandboxEventServedBackend as ma, terminateProcessTreeAndConfirm as mi, defaultSelectWinner as mn, recoverRetainedRun as mr, resolveSpawnResourcePaths as mt, createRootHandle as n, detachedSnapshot as na, runSettledCommand as ni, peerMailTools as nn, BudgetReconcileFault as nr, noteScopeRetainedOwnerCoordination as nt, pickBestDelivered as o, canonicalStreamEventFromSandboxEvent as oa, removeWorktree as oi, bridgeAdmissionRefusal as on, meterUsageEvent as or, scopeRetainedOwnerPriorSpend as ot, summarizeDriverAttempts as p, notifySandboxEventObserver as pa, CodexExecutionDiagnosticError as pi, createSandboxForSpec as pn, reconnectRetainedRun as pr, hostDirectoryReader as pt, isWaitOutcome as q, runtimeOwnedExecutorMaterialization as qi, materializeTreeView as qn, loopEventToOtelSpan as qr, createActivityLog as qt, createSupervisor as r, projectSandboxOutcome as ra, runWorktreeHarness as ri, peerMailVerbNames as rn, ReservationWaitRefused as rr, prepareScopeRetainedOwnerTask as rt, runFinalizer as s, createSandboxToolPartState as sa, DEFAULT_LOCAL_HARNESS as si, bridgeModelRouteRefusal as sn, newUsageTotals as sr, scopeRetainedOwnerResourceReader as st, DEFAULT_MAX_DEPTH as t, detachedFrozen as ta, sanitizeRuntimeStreamEvent as ti, isPeerMailEnvelope as tn, executorFailure as tr, consumeScopeRetainedOwnerResult as tt, HarnessTurnFailedError as u, isSandboxTerminalEvent as ua, harnessSupportsReasoningEffort as ui, harnessUsageIsEmpty as un, bridgeRuntimeAttachmentsKey as ur, scopeRetainedOwnerTurnEnded as ut, admitContinuationPolicy as v, chargedTokens as va, defineProfileMaterializationContract as vi, probeSandboxCapabilities as vn, destroyInteractiveEnvironment as vr, attachWorker as vt, distillFindings as w, randomSuffix as wa, promptResourceProfileMaterialization as wi, routerBrain as wn, linkAbort as wr, startRetainedInteractiveRun as wt, checkVerdictOf as x, hasCompleteCacheBreakdown as xa, promptControlProfileMaterialization as xi, captureBeforeDestroy as xn, openSlotGroup as xr, workerInteractiveBindingsDir as xt, admitFinding as y, cloneSpend as ya, fullProfileMaterialization as yi, acquireSandbox as yn, environmentGone as yr, readWorkerInteractiveBinding as yt, meterRuntimeOwnedProviderAttempt as z, armDeadlineTimer as za, inheritRuntimeOwnedExecutorAttestation as zi, FileSpawnJournal as zn, resolveRedactor as zr, createInPlaceCliExecutor 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-DA_nvF-h.js.map
+//# sourceMappingURL=supervisor-DYKPbcZa.js.map