@tangle-network/agent-runtime 4.0.0 → 6.0.1

package/dist/{supervisor-CwANBb9-.js → supervisor-B6sl14OR.js}

@@ -1,8 +1,8 @@
-import { $i as parseCodexUsageRecord, $r as DISPATCH_EXECUTION_CHANGED_CODE, A as nestedScopeSeamKey, An as workerTraceEnv, Ar as recordRuntimeOwnedProviderAttemptStart, Bi as extractTransportEventIdentity, Br as unknownExecutionBindingReceipt, Bt as retainedOwnerWorkspaceRetentionSeamKey, Ci as hashJson, Cn as nativeCopyDelayMs, Cr as finalizeRuntimeOwnedPendingExecutor, Dr as newExecutionAttemptId, Ei as createBudgetPool, Er as knownMaterializationReceipt, Fi as sandboxLeafOutputFromEvents, Fr as runtimeOwnedExecutorExecutionBinding, Hi as canonicalSandboxUsageMode, Hr as executableAgentProfileSnapshot, Ii as sandboxOutputMarker, Ir as runtimeOwnedExecutorMaterialization, Ji as sameModelId, Jr as runtimeFailureCause, Jt as nestedDriverTreeRoot, Ki as isSandboxTerminalEvent, Kt as attestNestedDriverTreeOwner, Li as sandboxProgressEvents, Lt as scopeRetainedOwnerCheckpointing, Mi as createSandboxToolPartState, Mr as recordRuntimeOwnedProviderIdentityConflict, Nn as mergeTraceEnv, Nr as recordRuntimeOwnedProviderModel, On as resolveWorkerSlots, Q as assertRecursiveReservationPolicy, Qn as harnessTranscriptUnavailable, Qt as closesCursorSlot, R as appendSpawnEvents, Si as executorFailureInfra, Sn as captureProviderWorkspaceSnapshot, T as sumSpendFromEvents, Ti as isCredentialRefusal, Tn as workspaceCaptureReceipt, Tr as knownExecutionBindingReceipt, Ui as createSandboxTurnEventCollector, Ur as executableAgentSpecSnapshot, Ut as loadSpawnForest, V as finalizeScopeOwnerMaterialization, Vi as assertSandboxServedModel, Vr as unknownMaterializationReceipt, Wi as createSandboxUsageLedger, Wt as ownedTreeRootSpawn, X as reenteredWorkers, Xi as sandboxTerminalUsageField, Xr as runtimeFailureRemediationSchema, Xt as encodeResultBlob, Yi as sandboxEventServedBackend, Yn as captureHarnessTranscript, Zn as harnessTranscriptFromLines, Zr as runtimeProviderCode, Zt as SpawnEventIndex, _r as attestRuntimeOwnedDeferredExecutor, _t as startScopeRecoveries, aa as freezeControlRef, an as reconnectRetainedRun, at as hasRetriableTeardowns, bi as contentRef, bn as assertProviderWorkspaceRetentionPort, ca as RunCancellationReason, ci as UNAVAILABLE_CODES, da as runAbortable, dt as registerNestedTeardownScope, ea as recordValue, ei as DISPATCH_NOT_ADMITTED_CODE, en as verifyWorkspaceMarker, fi as printedStatus, ft as releaseHeldEnvironments, gi as unavailableSignalOfFailure, gr as subscriptionUsageLimitSignal, gt as settleManagerWork, ht as retryUnconfirmedTeardowns, ia as exactSession, ii as isSchemaRejection, in as mintRetainedIdentity, ir as retainHarnessTranscript, it as closeScopeAdmission, jn as workerTraceHeaders, jr as recordRuntimeOwnedProviderDispatchNotStarted, jt as scopeRetainedOwnerSettled, kn as WORKER_TRACE_PROPAGATION, la as abortReason, li as UNAVAILABLE_STATUSES, lr as isLiveNodeStatus, ma as promptOptionsFromAgentTurnInput, mi as unavailablePauseMs, mt as releaseRetainedEnvironments, na as assertEventBinding, ni as TRANSPORT_ERROR_CODES, nn as stopRetainedNativeExecution, oa as isTerminalSessionStatus, oi as retainedExecutorContext, on as recoverRetainedRun, or as createActivityLog, pt as releaseManagerEnvironment, qi as notifySandboxEventObserver, qn as HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS, qr as reportedFailureCause, qt as driverRuntime, ra as awaitAbortable, ri as isProvisioningRefusal, rn as assertRetainedRunReplayMaterial, rt as closeRetainedSlots, sa as sameControlCoordinates, si as retainedExecutorSeamKey, sn as startRetainedRun, sr as describeToolArgs, t as createScope, ta as RetainedRunProviderContractError, ti as RetainedExecutionPendingError, tn as describeRetainedNativeStops, ua as linkAbort, vn as environmentGone, vr as attestRuntimeOwnedExecutor, vt as unconfirmedTeardowns, w as prepareScopeResume, wi as credentialCommandExit, wn as openNativeMirror, wr as inheritRuntimeOwnedExecutorAttestation, xn as captureProviderLiveWorkspace, yi as contentAddress, yr as attestRuntimeOwnedPendingExecutor, yt as waitForScopeChildren, zr as runtimeOwnedScopeOwnerRuntime } from "./scope-CJ7xtrs8.js";
+import { $ as hasRetriableTeardowns, $i as parseCodexUsageRecord, $r as RetainedExecutionPendingError, An as mergeTraceEnv, Ar as recordRuntimeOwnedProviderModel, Bi as extractTransportEventIdentity, Br as executableAgentProfileSnapshot, Ci as hashJson, Cr as knownMaterializationReceipt, D as prepareScopeResume, Dn as workerTraceEnv, Dr as recordRuntimeOwnedProviderAttemptStart, E as resolveWorkerSlots, Ei as createBudgetPool, En as WORKER_TRACE_PROPAGATION, Fi as sandboxLeafOutputFromEvents, Gr as reportedFailureCause, Hi as canonicalSandboxUsageMode, Ht as scopeRetainedOwnerCheckpointing, Ii as sandboxOutputMarker, Ir as runtimeOwnedScopeOwnerControl, It as scopeRetainedOwnerSettled, Ji as sameModelId, Jn as harnessTranscriptFromLines, Jr as runtimeFailureRemediationSchema, Jt as ownedTreeRootSpawn, K as assertRecursiveReservationPolicy, Ki as isSandboxTerminalEvent, Kn as captureHarnessTranscript, Kr as runtimeFailureCause, Li as sandboxProgressEvents, Lr as runtimeOwnedScopeOwnerRuntime, Mi as createSandboxToolPartState, Mr as runtimeOwnedExecutorExecutionBinding, N as nestedScopeSeamKey, Nr as runtimeOwnedExecutorMaterialization, O as sumSpendFromEvents, On as workerTraceHeaders, Or as recordRuntimeOwnedProviderDispatchNotStarted, Q as closeScopeAdmission, Qr as DISPATCH_NOT_ADMITTED_CODE, Qt as nestedDriverTreeRoot, Rr as unknownExecutionBindingReceipt, Si as turnFailurePolicy, Sr as knownExecutionBindingReceipt, Ti as isCredentialRefusal, Tn as environmentGone, Tt as finalizeScopeOwnerMaterialization, U as appendTeardownConfirmation, Ui as createSandboxTurnEventCollector, V as appendSpawnEvents, Vi as assertSandboxServedModel, Vr as executableAgentSpecSnapshot, W as reenteredWorkers, Wi as createSandboxUsageLedger, Wn as HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS, Wt as bindScopeRetainedOwnerProvider, Xi as sandboxTerminalUsageField, Xt as attestNestedDriverTreeOwner, Yi as sandboxEventServedBackend, Yn as harnessTranscriptUnavailable, Yr as runtimeProviderCode, Z as closeRetainedSlots, Zr as DISPATCH_EXECUTION_CHANGED_CODE, Zt as driverRuntime, _i as contentAddress, aa as freezeControlRef, ai as retainedExecutorSeamKey, bi as executorFailureInfra, br as finalizeRuntimeOwnedPendingExecutor, ca as abortReason, cn as stopRetainedNativeExecution, ct as releaseRetainedEnvironments, di as reportedResetAt, dn as mintRetainedIdentity, dt as startScopeRecoveries, ea as recordValue, ei as TRANSPORT_ERROR_CODES, en as encodeResultBlob, fi as unavailablePauseMs, fn as reconnectRetainedRun, ft as unconfirmedTeardowns, gr as attestRuntimeOwnedPendingExecutor, hr as attestRuntimeOwnedExecutor, ia as exactSession, ii as retainedExecutorContext, in as executorObservation, ir as describeToolArgs, kr as recordRuntimeOwnedProviderIdentityConflict, la as linkAbort, ln as verifyWorkspaceMarker, lt as retryUnconfirmedTeardowns, mi as unavailableSignalOfFailure, mn as startRetainedRun, mr as attestRuntimeOwnedDeferredExecutor, na as assertEventBinding, ni as isSchemaRejection, nn as closesCursorSlot, oa as sameControlCoordinates, oi as UNAVAILABLE_CODES, on as observeModelRequest, or as isLiveNodeStatus, ot as registerNestedTeardownScope, pa as promptOptionsFromAgentTurnInput, pi as unavailableResumeAt, pn as recoverRetainedRun, pr as subscriptionUsageLimitSignal, pt as waitForScopeChildren, qi as notifySandboxEventObserver, qt as loadSpawnForest, ra as awaitAbortable, rr as createActivityLog, sa as RunCancellationReason, si as UNAVAILABLE_STATUSES, sn as describeRetainedNativeStops, st as releaseHeldEnvironments, t as createScope, ta as RetainedRunProviderContractError, ti as isProvisioningRefusal, tn as SpawnEventIndex, ua as runAbortable, ui as printedStatus, un as assertRetainedRunReplayMaterial, ut as settleManagerWork, vi as contentRef, wi as credentialCommandExit, wr as newExecutionAttemptId, xi as turnFailureOf, xr as inheritRuntimeOwnedExecutorAttestation, zr as unknownMaterializationReceipt } from "./scope-DzhBJrRN.js";
 import { f as RuntimeRunStateError, i as ConfigError, m as ValidationError$1, r as BackendTransportError, t as AgentEvalError } from "./errors-AzSuGI23.js";
-import { $ as isAsyncIterable, J as deleteBoxSafe, Ot as teardownSurfaces, Q as isAbortError, St as armDeadlineTimer, Tt as isDeadlineAbortReason, U as addSpend, V as hasControlCharacter, W as addTokenUsage, Y as errorMessage, _t as ACCEPTED_RESULT_GRACE_MS, at as sleep, ct as throwIfAborted, dt as zeroSpend, et as mapWithConcurrency, ft as zeroTokenUsage, gt as withBudgetResources, it as roundBoxMinutes, lt as unmeteredSpend, nt as randomSuffix, ot as stringifySafe, pt as addResourceSpend, q as cloneTokenUsage, rt as randomUuid, st as throwAbort, tt as promptCacheTokenClasses, ut as withTimeout, xt as ROOT_DEADLINE_REASON } from "./workspace-streams-8ALHaZzx.js";
+import { $ as mapWithConcurrency, B as hasControlCharacter, H as addSpend, J as errorMessage, K as cloneTokenUsage, Ot as teardownSurfaces, Q as isAsyncIterable, St as armDeadlineTimer, Tt as isDeadlineAbortReason, U as addTokenUsage, Z as isAbortError, _t as ACCEPTED_RESULT_GRACE_MS, at as stringifySafe, ct as unmeteredSpend, dt as zeroSpend, et as promptCacheTokenClasses, ft as zeroTokenUsage, gt as withBudgetResources, it as sleep, lt as unreportedSpend, nt as randomUuid, ot as throwAbort, pt as addResourceSpend, q as deleteBoxSafe, rt as roundBoxMinutes, st as throwIfAborted, tt as randomSuffix, ut as withTimeout, xt as ROOT_DEADLINE_REASON } from "./workspace-streams-BqNM06y4.js";
 import { t as runTaskQueue } from "./task-queue-DbpZAp6C.js";
-import { _ as errorText, d as detachedSnapshot, g as errorProperty, h as errorHttpStatus, l as sha256, m as errMessage, p as causeChain, v as defaultRedactor } from "./jsonl-file-CvPuwM0a.js";
+import { _ as errorText, d as detachedSnapshot, g as errorProperty, h as errorHttpStatus, l as sha256, m as errMessage, p as causeChain, v as defaultRedactor } from "./jsonl-file-CeVYTIQJ.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-JOcg3NRs.js";
 import { r as nativeSystemPrompt, t as assertSandboxProfileCompatibility } from "./sandbox-profile-compat-oFGWESLn.js";
 import { a as writeAtomicDurableFile, s as fenceRunWrite } from "./durable-file-DstVeHcj.js";
@@ -5591,13 +5591,7 @@ const causedByPartialFailure = (error) => causeChain(error).some((cause) => caus
 function abandonablePending(error) {
 	return error instanceof RetainedExecutionPendingError && (error.pendingCause === "unobservable" || error.pendingCause === "nested-recovery") ? error : void 0;
 }
-/**
-* Bridge error classes the bridge itself never retries: a request that fails identically on
-* every attempt, mapped below 5xx on its HTTP path (`parse_error` 400, the other two 501). On the
-* stream path the same failure arrives with no status at all — a profile that cannot materialize
-* is a `parse_error` — and the status split alone read it as a bad moment and re-drove it to the
-* attempt ceiling.
-*/
+/** Deterministic bridge refusals remain terminal even when transport omits HTTP status. */
 const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
 	"parse_error",
 	"not_configured",
@@ -5612,15 +5606,7 @@ const DETERMINISTIC_BRIDGE_CODES = /* @__PURE__ */ new Set([
 */
 const CONTENT_FILTER_REASON = "refused by the model provider's content filter";
 const isContentFilterRefusal = (error) => causeChain(error).some((cause) => cause instanceof Error && /\bcontent was flagged for possible\b/iu.test(errorProperty(cause, "message") ?? ""));
-/**
-* A driver's harness turn ran to its terminal result, and that result reported failure.
-*
-* A provider executor returns a failed turn as an outcome; without this error it reads as a
-* completed drive and never reaches the retry decision (a turn ended `status code 524`).
-*
-* `errorCode` is the provider's machine code when it reported one. The classifier reads the code;
-* text decides only a printed capacity code and a content-filter refusal, which have none.
-*/
+/** A completed failed turn enters retry with its producer classification and legacy metadata intact. */
 var HarnessTurnFailedError = class extends Error {
 	runtime;
 	/** The failure as the harness reported it, before this error's framing. */
@@ -5629,11 +5615,13 @@ var HarnessTurnFailedError = class extends Error {
 	statusCode;
 	/** The shared HTTP error reader also uses this status for persisted diagnostics. */
 	status;
+	failure;
 	constructor(runtime, failure) {
 		super(`${runtime} harness turn ended with a failed outcome` + (failure.errorCode === void 0 ? "" : ` (${failure.errorCode})`) + `: ${failure.error}`);
 		this.name = "HarnessTurnFailedError";
 		this.runtime = runtime;
 		this.reported = failure.error;
+		if (failure.failure !== void 0) this.failure = failure.failure;
 		if (failure.errorCode !== void 0) this.errorCode = failure.errorCode;
 		if (failure.statusCode !== void 0) {
 			this.statusCode = failure.statusCode;
@@ -5665,23 +5653,21 @@ function isDispatchExecutionChanged(value) {
 		return false;
 	}
 }
-/**
-* The code or status that marks `error` as an upstream capacity refusal, or `undefined`.
-*
-* A structured field is read first: a turn outcome's `errorCode`, a transport error's
-* `upstreamCode` and `status`, a provider SDK error's `code` and `status`. The failure text is read
-* only as {@link unavailableSignalOfFailure} says, because a harness CLI reports the router's
-* refusal as text and Sandbox's held-room refusal shares its code with a shape that never fits.
-*/
+/** Read Runtime admission evidence before producer hints and legacy transport metadata. */
 function upstreamUnavailableSignal(error) {
 	if (undispatchedCredentialExit(error) !== void 0) return "credential-unavailable";
+	if (error instanceof CheckUnavailableError) return "check-unavailable";
+	if (error instanceof CoordinationUnreachableError) return "coordination-unreachable";
+	const typed = turnFailureOf(error);
+	if (typed) return turnFailurePolicy(typed).classification === "unavailable" ? subscriptionUsageLimitSignal({
+		error: "",
+		errorCode: typed.code
+	}) ?? typed.code : void 0;
 	const refusal = retainedAdmissionCause(error) ?? reconciliationCapacityRefusal(error);
 	if (refusal !== void 0) return upstreamUnavailableSignal(refusal);
 	if (!(error instanceof Error)) return void 0;
 	if (isCredentialRefusal(error)) return void 0;
 	if (isProviderSchemaRejection(error)) return void 0;
-	if (error instanceof CheckUnavailableError) return "check-unavailable";
-	if (error instanceof CoordinationUnreachableError) return "coordination-unreachable";
 	const transport = error instanceof BackendTransportError;
 	if (error instanceof AgentEvalError && !transport) return void 0;
 	const harness = error instanceof HarnessTurnFailedError;
@@ -5692,13 +5678,7 @@ function upstreamUnavailableSignal(error) {
 	};
 	return (harness ? subscriptionUsageLimitSignal(failure) : void 0) ?? unavailableSignalOfFailure(failure);
 }
-/**
-* The capacity refusal an admitted execution's reconciliation met: a cause with an upstream
-* capacity code or HTTP 429. The execution is unresolved, not failed, so the driver pauses and
-* reconciles it again, never abandoning it; a contract violation stays terminal (#1204).
-* magnetar-rust-sandbox-20261102a's managers met `TangleCredentialCapacityError: HTTP 429` on
-* 1,407 reconciliations, each classed transient.
-*/
+/** Capacity encountered while reconciling an admitted execution pauses that same execution. */
 function reconciliationCapacityRefusal(error) {
 	if (!(error instanceof RetainedExecutionPendingError) || error.phase !== "execution") return void 0;
 	if (error.pendingCause !== "unobservable" && error.pendingCause !== "transport") return void 0;
@@ -5714,21 +5694,10 @@ function ownCode(error) {
 		return;
 	}
 }
-/**
-* Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal; an
-* upstream capacity refusal is `unavailable`; anything else foreign is an accident and is
-* retryable. A `BackendTransportError` is split by status because the taxonomy already promises
-* consumers may branch on it: a 5xx/408 is the upstream having a bad moment, a 429/503/529 is the
-* upstream out of capacity, and a 401/404/422 is a request that will fail identically forever. The
-* bridge's own never-retry classes are terminal whether or not a status rides with them.
-*
-* An `AbortError` is the run's own only when `signal` (the run) or `stopSignal` (the manager's own
-* stop: an accepted result, `stop`, a stop rule) has fired. Any other is a lost stream and is
-* retried: on magnetar-rust-20261019b a 4.0 h root turn ended "bridgeExecutor: turn aborted" and,
-* classed terminal, settled the run after one attempt.
-*/
+/** Runtime cancellation/contracts dominate producer policy; untyped foreign failures retain legacy rules. */
 function classifyDriverFailure(error, signal, stopSignal) {
 	if (signal?.aborted) return "terminal";
+	if (error instanceof CheckUnavailableError || error instanceof CoordinationUnreachableError) return "unavailable";
 	if (error instanceof RetainedExecutionPendingError && error.pendingCause === "provider-contract") return "terminal";
 	if (undispatchedCredentialExit(error) !== void 0) return "unavailable";
 	const admission = retainedAdmissionCause(error);
@@ -5739,6 +5708,9 @@ function classifyDriverFailure(error, signal, stopSignal) {
 	if (error instanceof Error && isProviderSchemaRejection(error)) return "terminal";
 	if (isCredentialRefusal(error)) return "terminal";
 	if (causeChain(error).some(isProvisioningRefusal)) return "terminal";
+	if (error instanceof AgentEvalError && !(error instanceof BackendTransportError)) return "terminal";
+	const typed = turnFailureOf(error);
+	if (typed) return turnFailurePolicy(typed).classification;
 	if (error instanceof HarnessTurnFailedError) {
 		if (error.errorCode !== void 0 && DETERMINISTIC_BRIDGE_CODES.has(error.errorCode)) return "terminal";
 		if (upstreamUnavailableSignal(error) !== void 0) return "unavailable";
@@ -5750,7 +5722,6 @@ function classifyDriverFailure(error, signal, stopSignal) {
 		const status = error.status;
 		return status === void 0 || status === 408 || status >= 500 ? "transient" : "terminal";
 	}
-	if (error instanceof AgentEvalError) return "terminal";
 	if (upstreamUnavailableSignal(error) !== void 0) return "unavailable";
 	return foreignHttpStatusVerdict(error) ?? "transient";
 }
@@ -5821,14 +5792,10 @@ const TRANSPORT_NAMES = /* @__PURE__ */ new Set([
 	"AbortError",
 	"RetainedStreamError"
 ]);
-/**
-* A transient failure's kind, read from typed fields on any cause, never its text. `infra` is a
-* transport that dropped, timed out or answered 408 or 5xx, and earns the outage bound; anything
-* else foreign is `deterministic`, an answer that repeats, and earns no window. Of 4,449 failed
-* attempts over the week to 2026-11-04, 2,019 were deterministic answers retried as transient
-* (a failed box's 409, a play repository's exit 128, an expired key's 401, a harness refusal).
-*/
+/** Producer infra earns the outage window; producer work earns only the bounded deterministic streak. */
 function transientFailureKind(error) {
+	const typed = turnFailureOf(error);
+	if (typed) return turnFailurePolicy(typed).failureKind;
 	if (causedByPartialFailure(error)) return "deterministic";
 	return causeChain(error).some((cause) => {
 		if (!(cause instanceof Error)) return false;
@@ -6217,6 +6184,11 @@ function* chunkProgress(chunk, ledger, args) {
 			progress: {
 				kind: "tool_result",
 				toolName: result.name,
+				status: result.status === "completed" ? "ok" : "error",
+				...result.status === "error" ? { error: {
+					type: "bridge-tool-error",
+					message: result.error ?? "tool failed"
+				} } : {},
 				...result.id === void 0 ? {} : { toolCallId: result.id },
 				result: result.status === "completed" ? result.output : { error: result.error }
 			}
@@ -7648,7 +7620,6 @@ function executionTaskPrompt$1(task, configuredPrompt) {
 	return prompt;
 }
 // src/runtime/supervise/runtime-seams.ts
-const sandboxCaptureOutputSeamKey = "runtime.sandboxCaptureOutput";
 const routerSeamKey = "router";
 const sandboxSeamKey = "sandbox";
 const cliWorktreeSeamKey = "cli-worktree";
@@ -7995,374 +7966,6 @@ function publicCreateOptions(create) {
 		...secrets === void 0 ? {} : { secretNames: Array.isArray(secrets) ? [...secrets].sort() : Object.keys(secrets).sort() }
 	};
 }
-// src/runtime/environment-provider/provider-retention-lifecycle.ts
-function createProviderCaptureMirrors(options, createProfile, node, state) {
-	const nativePort = options.workspaceRetention?.captureNative === void 0 ? void 0 : options.workspaceRetention;
-	let nativeInFlight;
-	let nativeRunningInFlight;
-	let nativeRunningStop;
-	let nativeTimer;
-	let nativeEvents = 0;
-	let nativeEventsAtCopy;
-	let lastNativeCopyMs = 0;
-	let closeNativeMirror;
-	const livePort = options.workspaceRetention?.captureLive === void 0 ? void 0 : options.workspaceRetention;
-	let liveInFlight;
-	let liveTimer;
-	let liveStop;
-	const stopLiveMirror = () => {
-		if (liveTimer !== void 0) clearTimeout(liveTimer);
-		liveTimer = void 0;
-		liveStop?.abort(/* @__PURE__ */ new Error("live workspace capture stopped: its turn ended"));
-		liveStop = void 0;
-	};
-	const startLiveMirror = (next) => {
-		if (livePort?.liveIntervalMs === void 0) return;
-		stopLiveMirror();
-		const stop = new AbortController();
-		liveStop = stop;
-		const schedule = () => {
-			liveTimer = setTimeout(() => {
-				if (liveInFlight === void 0 && state.workspaceCapturePromise === void 0) {
-					const tracked = captureProviderLiveWorkspace(livePort, {
-						environment: next,
-						executionId: state.workspaceExecutionId,
-						...state.workspaceControlRef === void 0 ? {} : { controlRef: state.workspaceControlRef },
-						...node === void 0 ? {} : { node },
-						providerSessionId: state.providerSessionId,
-						nativeSessionId: null,
-						profile: createProfile
-					}, stop.signal).then(() => void 0, () => void 0).finally(() => {
-						if (liveInFlight === tracked) liveInFlight = void 0;
-					});
-					liveInFlight = tracked;
-				}
-				schedule();
-			}, livePort.liveIntervalMs);
-			liveTimer.unref?.();
-		};
-		schedule();
-	};
-	let nativeHoldsTranscript = false;
-	const noteCaptureFailure = (error) => {
-		if (nativeHoldsTranscript || state.harnessTranscript.status !== "unavailable") return;
-		if (state.harnessTranscript.reason !== "capture-did-not-run" && state.harnessTranscript.reason !== "enumeration-failed") return;
-		state.harnessTranscript = {
-			status: "unavailable",
-			reason: "enumeration-failed",
-			skipped: [{
-				path: state.workspaceExecutionId,
-				reason: errorText(error instanceof Error ? error.message : error)
-			}]
-		};
-	};
-	const stopNativeMirror = async () => {
-		if (nativeTimer !== void 0) clearTimeout(nativeTimer);
-		nativeTimer = void 0;
-		closeNativeMirror?.();
-		closeNativeMirror = void 0;
-		nativeRunningStop?.abort(/* @__PURE__ */ new Error("native session copy stopped: its turn ended"));
-		nativeRunningStop = void 0;
-		await nativeInFlight;
-	};
-	const captureNative = (next, phase, admitted, afterStop = false) => {
-		if (nativePort === void 0 || createProfile.harness === void 0) return Promise.resolve();
-		const harness = createProfile.harness;
-		const stop = phase === "running" ? new AbortController() : void 0;
-		if (stop !== void 0) nativeRunningStop = stop;
-		const tracked = (nativeInFlight ?? Promise.resolve()).then(async () => {
-			stop?.signal.throwIfAborted();
-			const controlRef = state.workspaceControlRef ?? admitted;
-			const sessionId = state.providerSessionId ?? admitted?.sessionId ?? null;
-			if (state.workspaceSnapshot !== void 0 && !nativeHoldsTranscript) return;
-			const invocationId = state.workspaceExecutionId;
-			const eventsAtStart = nativeEvents;
-			const copyStartedAt = Date.now();
-			try {
-				const takeCopy = () => captureProviderWorkspaceSnapshot(nativePort, {
-					environment: next,
-					executionId: invocationId,
-					...controlRef === void 0 ? {} : { controlRef },
-					...node === void 0 ? {} : { node },
-					providerSessionId: sessionId,
-					nativeSessionId: null,
-					profile: createProfile,
-					phase
-				}, "native", void 0, stop?.signal);
-				let captured = await takeCopy();
-				const settleBy = Date.now() + NATIVE_SETTLE_WINDOW_MS;
-				while (afterStop && captured.coverageComplete !== true && (captured.provenance.attempts ?? []).some((attempt) => attempt.outcome === "unknown") && Date.now() < settleBy) {
-					await sleep(NATIVE_SETTLE_POLL_MS);
-					captured = await takeCopy();
-				}
-				if (state.workspaceSnapshot !== void 0 && !nativeHoldsTranscript) return;
-				const copy = retainHarnessTranscript(providerWorkspaceCaptureReceipt({
-					executionId: invocationId,
-					profile: createProfile,
-					...node === void 0 ? {} : { node },
-					workspaceControlRef: () => controlRef,
-					workspaceProvenance: () => captured.provenance,
-					workspaceCoverage: () => ({
-						complete: captured.coverageComplete ?? false,
-						incompleteReason: captured.incompleteReason
-					})
-				}, next, captured.snapshot, sessionId), harness);
-				if (nativeHoldsTranscript && !(copy.status === "retained" && copy.fileCount > 0)) return;
-				state.harnessTranscript = copy;
-				nativeHoldsTranscript = true;
-				nativeEventsAtCopy = eventsAtStart;
-			} catch (error) {
-				if (stop?.signal.aborted) return;
-				noteCaptureFailure(error);
-			} finally {
-				lastNativeCopyMs = Date.now() - copyStartedAt;
-			}
-		}).catch(() => void 0).finally(() => {
-			if (nativeInFlight === tracked) nativeInFlight = void 0;
-			if (nativeRunningInFlight === tracked) nativeRunningInFlight = void 0;
-			if (nativeRunningStop === stop) nativeRunningStop = void 0;
-		});
-		nativeInFlight = tracked;
-		if (stop !== void 0) nativeRunningInFlight = tracked;
-		return tracked;
-	};
-	const startNativeMirror = (next) => {
-		startLiveMirror(next);
-		if (nativePort === void 0) return;
-		if (nativeTimer !== void 0) clearTimeout(nativeTimer);
-		closeNativeMirror?.();
-		closeNativeMirror = openNativeMirror(nativePort);
-		const port = nativePort;
-		const interval = nativePort.nativeIntervalMs ?? 12e4;
-		const schedule = () => {
-			nativeTimer = setTimeout(() => {
-				if (nativeInFlight === void 0 && !(nativeHoldsTranscript && nativeEventsAtCopy === nativeEvents)) captureNative(next, "running");
-				schedule();
-			}, nativeCopyDelayMs(port, interval, lastNativeCopyMs));
-			nativeTimer.unref?.();
-		};
-		schedule();
-	};
-	const finishNativeMirror = async (next, phase) => {
-		stopLiveMirror();
-		await stopNativeMirror();
-		if (state.workspaceSnapshot !== void 0 && !nativeHoldsTranscript) return;
-		await captureNative(next, phase, void 0, state.harnessStopped);
-	};
-	return {
-		get nativePort() {
-			return nativePort;
-		},
-		get nativeRunningInFlight() {
-			return nativeRunningInFlight;
-		},
-		get liveInFlight() {
-			return liveInFlight;
-		},
-		get holdsTranscript() {
-			return nativeHoldsTranscript;
-		},
-		set holdsTranscript(value) {
-			nativeHoldsTranscript = value;
-		},
-		stopScheduledNativeCapture() {
-			if (nativeTimer !== void 0) clearTimeout(nativeTimer);
-			nativeTimer = void 0;
-		},
-		noteProviderEvent() {
-			nativeEvents += 1;
-		},
-		noteCaptureFailure,
-		stopLiveMirror,
-		captureNative,
-		startNativeMirror,
-		finishNativeMirror
-	};
-}
-/** How long the final copy of a stopped harness waits for the provider to record how it ended. */
-const NATIVE_SETTLE_WINDOW_MS = 15e3;
-const NATIVE_SETTLE_POLL_MS = 1e3;
-function createProviderNativeControl(provider, retention, managerStop, state) {
-	let nativeStop;
-	const cancelRetainedOnManagerStop = (handle) => {
-		if (managerStop === void 0) return;
-		const cancel = () => {
-			if (state.retained !== handle || !state.workspaceRunActive) return;
-			handle.cancel({
-				operationId: `manager-stop:${randomUUID()}`,
-				reason: String(managerStop.reason ?? "the manager stopped")
-			}).catch(() => void 0);
-		};
-		const stop = () => managerStop.reason === "result-accepted" ? void armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, cancel) : cancel();
-		if (managerStop.aborted) stop();
-		else managerStop.addEventListener("abort", stop, { once: true });
-	};
-	/** Stop the native harness of this executor's retained execution, which local observation ending
-	*  never stops. Undefined when nothing was dispatched. */
-	const stopNativeExecution = () => {
-		if (nativeStop !== void 0) return nativeStop;
-		const controlRef = state.retained?.controlRef ?? admittedControlRef(retention);
-		if (controlRef === void 0) return Promise.resolve(void 0);
-		const stopping = stopRetainedNativeExecution({
-			provider,
-			controlRef,
-			...state.retained === void 0 ? {} : { handle: state.retained },
-			signal: AbortSignal.timeout(NATIVE_STOP_TIMEOUT_MS)
-		}).then((stop) => {
-			if (stop.effect === "cancelled" || stop.effect === "not_live") state.harnessStopped = true;
-			else if (nativeStop === stopping) nativeStop = void 0;
-			return stop;
-		});
-		nativeStop = stopping;
-		return stopping;
-	};
-	/** A turn its deadline or an explicit cancellation ended stops its harness, within the stop's
-	*  bound, before the turn's final native copy, which otherwise reads a session still written. */
-	const stopEndedHarness = async (signal) => {
-		if (!isDeadlineAbortReason(signal.reason) && !state.cancelledExplicitly()) return;
-		await stopNativeExecution();
-	};
-	/**
-	* A release that keeps an environment keeps its files, never its running harness. The root has
-	* settled and no process will reconcile this execution, so its native process stops before the
-	* release records what it kept.
-	*/
-	const withoutRunningHarness = (release) => async (signal) => {
-		const stop = await awaitAbortable(stopNativeExecution(), signal).catch(() => void 0);
-		const stopped = stop === void 0 ? "native stop unconfirmed: no exact dispatch or cleanup interrupted" : describeRetainedNativeStops([stop]);
-		const environmentId = (state.retained?.controlRef ?? admittedControlRef(retention))?.environmentId ?? admittedEnvironmentId(retention);
-		if (environmentId !== void 0 && !state.harnessStopped) {
-			state.workspacePreservationRequired = true;
-			return [{
-				provider: provider.name,
-				environmentId,
-				destroyed: false,
-				detail: stopped,
-				permanent: true
-			}];
-		}
-		return (await release(signal)).map((receipt) => receipt.destroyed ? receipt : {
-			...receipt,
-			detail: receipt.detail ? `${receipt.detail}; ${stopped}` : stopped
-		});
-	};
-	return {
-		cancelRetainedOnManagerStop,
-		stopNativeExecution,
-		stopEndedHarness,
-		withoutRunningHarness
-	};
-}
-/** The exact run the latest durable dispatch names, when dispatch got that far. */
-function admittedControlRef(retention) {
-	for (const admission of [...retention?.admissions ?? []].reverse()) if (admission.phase === "dispatched") return admission.controlRef;
-}
-/** Bounds one provider stop: a reconnect, the exact cancellation and its status read. */
-const NATIVE_STOP_TIMEOUT_MS = 3e4;
-function providerWorkspaceCaptureReceipt(args, environment, snapshot, fallbackSessionId) {
-	const coverage = args.workspaceCoverage();
-	const controlRef = args.workspaceControlRef();
-	return workspaceCaptureReceipt({
-		executionId: args.executionId,
-		...controlRef === void 0 ? {} : { controlRef },
-		...args.node === void 0 ? {} : { node: args.node },
-		environment,
-		profile: args.profile,
-		providerSessionId: controlRef?.sessionId ?? fallbackSessionId
-	}, {
-		snapshot,
-		provenance: args.workspaceProvenance() ?? {
-			status: "unavailable",
-			missing: ["Capture coverage metadata was not retained"]
-		},
-		coverageComplete: coverage.complete,
-		...coverage.incompleteReason === void 0 ? {} : { incompleteReason: coverage.incompleteReason }
-	});
-}
-// src/runtime/environment-provider/provider-workspace-capture.ts
-/** Capture the environment's workspace once per generation; later callers share that capture. */
-async function captureExecutorWorkspace(scope, next, outcome) {
-	const { state } = scope;
-	const workspaceRetention = scope.options.workspaceRetention;
-	if (workspaceRetention === void 0) return void 0;
-	state.resetWorkspace(next);
-	if (state.workspaceSnapshot !== void 0) return state.workspaceSnapshot;
-	if (state.workspaceCapturePromise === void 0) state.workspaceCapturePromise = startWorkspaceCapture(scope, workspaceRetention, next, outcome);
-	return await state.workspaceCapturePromise;
-}
-function startWorkspaceCapture(scope, workspaceRetention, next, outcome) {
-	const { state, mirrors, retention, node, createProfile } = scope;
-	state.workspaceOutcome = outcome;
-	mirrors.stopLiveMirror();
-	mirrors.stopScheduledNativeCapture();
-	const captureContext = {
-		environment: next,
-		executionId: state.workspaceExecutionId,
-		...state.workspaceControlRef === void 0 ? {} : { controlRef: state.workspaceControlRef },
-		...node === void 0 ? {} : { node },
-		providerSessionId: state.providerSessionId,
-		nativeSessionId: null,
-		profile: createProfile,
-		...outcome === void 0 ? {} : { outcome }
-	};
-	const reportTiming = retention?.onWorkspaceCapture;
-	let timing;
-	const capturedExecutionId = state.workspaceExecutionId;
-	const started = retention?.onWorkspaceCaptureStarted?.({
-		executionId: capturedExecutionId,
-		environmentId: next.id
-	}).catch(() => void 0) ?? Promise.resolve();
-	return Promise.all([mirrors.nativeRunningInFlight, mirrors.liveInFlight]).then(() => captureProviderWorkspaceSnapshot(workspaceRetention, captureContext, "environment", reportTiming === void 0 ? void 0 : (measured) => {
-		timing = measured;
-	})).finally(async () => {
-		await started;
-		if (timing === void 0 || reportTiming === void 0) return;
-		await reportTiming({
-			executionId: capturedExecutionId,
-			environmentId: next.id,
-			...timing
-		}).catch(() => void 0);
-	}).then((captured) => {
-		recordCapturedWorkspace(scope, workspaceRetention, next, captured);
-		return captured.snapshot;
-	}).catch((error) => {
-		state.workspaceCaptureFailure = error;
-		mirrors.noteCaptureFailure(error);
-		throw error;
-	});
-}
-/** Keep the capture's snapshot and provenance, and project its transcript for the executor. */
-function recordCapturedWorkspace(scope, workspaceRetention, next, { snapshot, provenance, coverageComplete, incompleteReason }) {
-	const { state, mirrors, node, createProfile } = scope;
-	state.workspaceSnapshot = snapshot;
-	state.workspaceProvenance = provenance;
-	state.workspaceCoverageComplete = coverageComplete ?? false;
-	state.workspaceIncompleteReason = incompleteReason;
-	try {
-		state.harnessTranscript = createProfile.harness === void 0 ? harnessTranscriptUnavailable("unknown-harness") : retainHarnessTranscript(providerWorkspaceCaptureReceipt({
-			executionId: state.workspaceExecutionId,
-			profile: createProfile,
-			...node === void 0 ? {} : { node },
-			workspaceControlRef: () => state.workspaceControlRef,
-			workspaceProvenance: () => provenance,
-			workspaceCoverage: () => ({
-				complete: coverageComplete ?? false,
-				incompleteReason
-			})
-		}, next, snapshot, state.providerSessionId), createProfile.harness);
-		mirrors.holdsTranscript = false;
-	} catch (error) {
-		if (!mirrors.holdsTranscript) state.harnessTranscript = {
-			status: "unavailable",
-			reason: "retained-projection-failed",
-			skipped: [{
-				path: state.workspaceExecutionId,
-				reason: error instanceof Error ? error.message : String(error)
-			}]
-		};
-	}
-	if (workspaceRetention.requireCompleteProvenance && !coverageComplete) state.workspacePreservationRequired = true;
-}
 // src/runtime/environment-provider/provider-environment-teardown.ts
 /** The environment id the latest durable admission names, when creation got that far. */
 function admittedEnvironmentId(retention) {
@@ -8372,56 +7975,28 @@ function admittedEnvironmentId(retention) {
 	}
 }
 const destroyFailed = (scope, error) => `providerAsExecutor(${scope.provider.name}): environment.destroy() failed — ${error instanceof Error ? error.message : String(error)}`;
-function workspaceFailureDetail(scope) {
-	const { workspaceCaptureFailure } = scope.state;
-	const reason = workspaceCaptureFailure instanceof Error ? workspaceCaptureFailure.message : String(workspaceCaptureFailure ?? "capture was not accepted");
-	return `providerAsExecutor(${scope.provider.name}): workspace retention failed — ${reason}; source environment preserved`;
-}
 /** Destroy the environment once, however many callers ask; a failed attempt may be retried. */
 async function destroyExecutorEnvironment(scope, cleanupSignal) {
-	const { state, options } = scope;
+	const { state } = scope;
 	if (state.workspaceCleanupPromise !== void 0) return await state.workspaceCleanupPromise;
 	const cleanupPromise = attemptDestroy(scope, cleanupSignal);
 	let cleanupReference;
 	cleanupReference = cleanupPromise.then((result) => {
-		if (!result.destroyed && state.workspaceCleanupPromise === cleanupReference && !state.workspacePreservationRequired && state.workspaceCaptureFailure === void 0) {
-			if (options.workspaceRetention !== void 0) {
-				state.workspaceSnapshot = void 0;
-				state.workspaceCapturePromise = void 0;
-			}
-			state.workspaceCleanupPromise = void 0;
-		}
+		if (!result.destroyed && state.workspaceCleanupPromise === cleanupReference && !state.workspacePreservationRequired) state.workspaceCleanupPromise = void 0;
 		return result;
 	});
 	state.workspaceCleanupPromise = cleanupReference;
 	return await cleanupReference;
 }
 async function attemptDestroy(scope, cleanupSignal) {
-	const { state, options, provider } = scope;
+	const { state, provider } = scope;
 	const target = state.environment;
 	if (target === void 0) return { destroyed: true };
 	if (state.workspacePreservationRequired) return {
 		destroyed: false,
-		detail: state.workspaceIncompleteReason ?? "provider workspace retention: source preserved because execution failed before a retrievable settled workspace receipt existed",
+		detail: "provider native stop was not confirmed; source environment preserved",
 		permanent: true
 	};
-	if (options.workspaceRetention !== void 0) try {
-		const currentSnapshot = await captureExecutorWorkspace(scope, target, state.workspaceOutcome);
-		if (state.workspacePublishedSnapshot !== void 0 && currentSnapshot !== void 0 && currentSnapshot.digest !== state.workspacePublishedSnapshot.digest) {
-			state.workspacePreservationRequired = true;
-			return {
-				destroyed: false,
-				detail: "provider workspace retention: live workspace changed after the published receipt; source preserved",
-				permanent: true
-			};
-		}
-	} catch {
-		return {
-			destroyed: false,
-			detail: workspaceFailureDetail(scope),
-			permanent: true
-		};
-	}
 	if (state.destroyed) return { destroyed: true };
 	try {
 		await awaitAbortable(Promise.resolve(target.destroy?.()), cleanupSignal);
@@ -8440,7 +8015,7 @@ async function attemptDestroy(scope, cleanupSignal) {
 }
 /** Release the environment of a retained execution once no process will reconcile it. */
 async function releaseRetainedExecution(scope, signal) {
-	const { state, options, provider, retention } = scope;
+	const { state, provider, retention } = scope;
 	scope.controller.abort();
 	if (!state.pending) return [];
 	const environmentId = state.retained?.controlRef.environmentId ?? state.environment?.id ?? admittedEnvironmentId(retention);
@@ -8452,12 +8027,11 @@ async function releaseRetainedExecution(scope, signal) {
 		...detail === void 0 ? {} : { detail },
 		...permanent === true ? { permanent } : {}
 	});
-	if (options.workspaceRetention !== void 0 && state.workspaceRunActive) return [receipt(false, "provider workspace retention: source preserved while execution is still active")];
 	if (state.retainedReleasePromise !== void 0) return await state.retainedReleasePromise;
 	const releasePromise = releaseReceipts(scope, environmentId, signal, receipt);
 	let releaseReference;
 	releaseReference = releasePromise.then((receipts) => {
-		if (state.retainedReleasePromise === releaseReference && !receipts.every((entry) => entry.destroyed) && !state.workspacePreservationRequired && state.workspaceCaptureFailure === void 0) state.retainedReleasePromise = void 0;
+		if (state.retainedReleasePromise === releaseReference && !receipts.every((entry) => entry.destroyed) && !state.workspacePreservationRequired) state.retainedReleasePromise = void 0;
 		return receipts;
 	});
 	state.retainedReleasePromise = releaseReference;
@@ -8478,7 +8052,7 @@ async function releaseReceipts(scope, environmentId, signal, receipt) {
 			state.environment = target;
 			state.resetWorkspace(target);
 		}
-		await captureBeforeDestroy$1(scope, target, signal);
+		await captureBeforeDestroy(scope, target, signal);
 		const result = await destroyExecutorEnvironment(scope, signal);
 		if (!result.destroyed) return [receipt(false, result.detail, result.permanent)];
 		state.pending = false;
@@ -8493,18 +8067,13 @@ async function releaseReceipts(scope, environmentId, signal, receipt) {
 * Discovery fleet of 2026-09-23/24, 105 carry `enumeration-failed`. A box the release can reach
 * is read once more before it is destroyed.
 */
-async function captureBeforeDestroy$1(scope, target, signal) {
-	const { state, options, mirrors, retention } = scope;
-	if (options.workspaceRetention === void 0 && state.harnessTranscript.status !== "captured" && !state.releaseReadTried) {
+async function captureBeforeDestroy(scope, target, signal) {
+	const { state } = scope;
+	if (state.harnessTranscript.status !== "captured" && !state.releaseReadTried) {
 		state.releaseReadTried = true;
 		const capture = await captureHarnessTranscript(target, scope.profile.harness, signal);
 		if (capture.status === "captured") state.harnessTranscript = capture;
 	}
-	if (mirrors.nativePort !== void 0 && state.harnessTranscript.status !== "retained" && !state.releaseNativeTried) {
-		state.releaseNativeTried = true;
-		const admitted = state.retained?.controlRef ?? admittedControlRef(retention);
-		await awaitAbortable(mirrors.captureNative(target, "interrupted", admitted === void 0 ? void 0 : freezeControlRef(admitted)), signal).catch(() => void 0);
-	}
 }
 // src/runtime/environment-provider/provider-validation-error.ts
 var ValidationError = class extends Error {
@@ -8576,13 +8145,15 @@ function providerFailureEvent(event, sandboxEvent) {
 	const detail = failureDetail(sandboxEvent.data) ?? failureDetail(outcome) ?? failureDetail(result) ?? (normalized?.type === "status" ? normalized.detail : void 0);
 	const errorCode = failureCode(sandboxEvent.data) ?? failureCode(outcome) ?? failureCode(result);
 	const statusCode = failureStatusCode(sandboxEvent.data) ?? failureStatusCode(outcome) ?? failureStatusCode(result);
+	const failure = turnFailureOf(sandboxEvent.data) ?? turnFailureOf(outcome) ?? turnFailureOf(result);
 	return {
 		type: "result",
 		data: {
 			status: "failed",
 			...detail ? { error: detail } : {},
 			...errorCode ? { errorCode } : {},
-			...statusCode === void 0 ? {} : { statusCode }
+			...statusCode === void 0 ? {} : { statusCode },
+			...failure === void 0 ? {} : { failure }
 		}
 	};
 }
@@ -8617,26 +8188,7 @@ function providerTerminalSuccess(event, sandboxEvent) {
 		result?.status
 	].some((status) => typeof status === "string" && TERMINAL_SUCCESS_STATUSES.has(status));
 }
-/**
-* Holds a stream's failure frames until it ends, so the terminal frame decides the outcome.
-*
-* The sandbox outcome tracker latches the first `error` frame as the run's error and settles
-* `failed` on it whatever the terminal frame says; and until this ledger existed the runtime
-* only ever showed the tracker its failure frames, so a terminal `success: true` was never in
-* evidence at all. A transport error that the harness recovered from — a stream break the
-* sidecar re-attached, a tool backend that failed once — therefore settled the whole child
-* `down` with the transient error as its reason, and the artifact the child had banked was
-* discarded. On the 2026-09-20 fleet corpus, 25 children that finished their work settled that
-* way.
-*
-* The rule: `error` frames are forgiven when the stream reports success and carries no verdict;
-* a failed status or a failed terminal frame is the provider's own verdict on the run, and once
-* one exists every failure frame is evidence again, in order, so the tracker names the first
-* `error` as it always did. The existing contracts hold unchanged: `status: failed` then
-* `done: {}` is failed, and the retained Claude tail `completed → failed → error → done` is
-* failed with the error frame's message. The forgiven frames stay in the event archive the trace
-* reads; only the outcome stops claiming them.
-*/
+/** Terminal success forgives recovered error frames; explicit failed verdicts retain their evidence. */
 function createProviderFailureLedger() {
 	const failures = [];
 	let verdicts = 0;
@@ -8655,7 +8207,12 @@ function createProviderFailureLedger() {
 			if (failures.length === 0 || verdicts === 0 && succeeded) return void 0;
 			const tracker = createAgentRunOutcomeTracker();
 			for (const frame of failures) tracker.observe(frame);
-			return tracker.finish();
+			const outcome = tracker.finish();
+			const failure = turnFailureOf(outcome) ?? failures.slice().reverse().map((frame) => turnFailureOf(frame.data)).find((value) => value !== void 0);
+			return outcome === void 0 ? void 0 : {
+				...outcome,
+				failure
+			};
 		}
 	};
 }
@@ -8838,12 +8395,8 @@ function stringValue(value) {
 const RETAINED_AWAITING_RESULT_AFTER_MS = 48e4;
 const RETAINED_STATUS_READ_MS = 6e4;
 const RETAINED_OBSERVATION_BATCH_EVENTS = 1024;
-/** After its exact result, a stream owing its terminal frame reads on while each frame comes this
-*  soon after the result or the last frame: a provider sends the two on separate connections. */
 const RETAINED_TAIL_FLOW_MS = 100;
-/** The event stream stopped short: a transport fact the retry policy reads by this name. */
 const streamFailure = (message) => Object.assign(new Error(message), { name: "RetainedStreamError" });
-/** Why the event stream stopped short, as bounded redacted text for the settlement reason. */
 function observationFailureText({ error }) {
 	const text = error instanceof Error ? error.message : String(error);
 	return String(defaultRedactor(text)).slice(0, 2048);
@@ -8853,23 +8406,29 @@ function exactQuotaRefusal(error) {
 	try {
 		const refusal = causeChain(error).find((cause) => Reflect.get(cause, "name") === "TangleCredentialCapacityError" && Reflect.get(cause, "code") === "provider_quota_exhausted");
 		if (refusal === void 0) return void 0;
+		const failure = turnFailureOf(refusal);
 		const resetAt = Reflect.get(refusal, "resetAt");
 		return {
 			text: "",
 			success: false,
 			error: `Subscription account capacity is unavailable${typeof resetAt === "string" ? ` until ${resetAt}` : ""}`,
 			errorCode: "provider_quota_exhausted",
-			statusCode: 429
+			statusCode: 429,
+			failure: failure ?? {
+				kind: "capacity",
+				code: "provider_quota_exhausted",
+				...typeof resetAt === "string" && Number.isFinite(Date.parse(resetAt)) ? { resetAt: new Date(resetAt).toISOString() } : {}
+			}
 		};
 	} catch {
 		return;
 	}
 }
-/** Everything one retained dispatch has observed of its event stream and exact result. */
 var RetainedObservation = class {
 	handle;
 	signal;
 	position;
+	quietMs;
 	failure;
 	lastReplayPosition;
 	resumedFrom;
@@ -8883,14 +8442,14 @@ var RetainedObservation = class {
 	exactWakers = /* @__PURE__ */ new Set();
 	seenEvents = /* @__PURE__ */ new Map();
 	pendingRead;
-	constructor(handle, signal, position) {
+	constructor(handle, signal, position, quietMs = RETAINED_AWAITING_RESULT_AFTER_MS) {
 		this.handle = handle;
 		this.signal = signal;
 		this.position = position;
+		this.quietMs = quietMs;
 		const observed = position?.observed;
 		if (observed?.executionId === handle.controlRef.executionId) this.lastReplayPosition = this.resumedFrom = observed.replayPosition;
 	}
-	/** Stream the provider's frames, resume once after a break, then yield the exact result. */
 	async *observe(session) {
 		this.lastObservedAt = Date.now();
 		if (!(yield* this.drain(session, this.resumedFrom)) && !this.sawTerminal && this.lastReplayPosition !== void 0) {
@@ -8901,11 +8460,13 @@ var RetainedObservation = class {
 		const resumed = this.resumedFrom && `retained provider stream resumed after ${this.resumedFrom}`;
 		if (resumed) this.failure ??= { error: streamFailure(resumed) };
 		if (!this.sawTerminal && this.failure === void 0) this.failure = { error: streamFailure("retained provider stream did not yield a terminal event") };
-		if (!this.sawTerminal && !this.exactResultSettled && this.silenceHandledAt === void 0) yield this.awaitingResult(Date.now());
-		while (!await this.exactOrQuiet()) await this.confirmRunLive(session);
+		if (!this.sawTerminal && !this.exactResultSettled && this.silenceHandledAt === void 0) {
+			yield this.awaitingResult(Date.now());
+			this.lastObservedAt = Date.now();
+		}
+		while (!await this.exactOrQuiet()) await this.stopQuietObservation(session);
 		yield await this.resultFrame();
 	}
-	/** True once the exact result settles, false once a quiet interval passes first. */
 	exactOrQuiet() {
 		let unwatch = [() => {}];
 		return new Promise((resolve) => {
@@ -8914,21 +8475,17 @@ var RetainedObservation = class {
 	}
 	armQuiet(onQuiet) {
 		const quietFrom = Math.max(this.lastObservedAt, this.silenceHandledAt ?? 0);
-		const quietMs = RETAINED_AWAITING_RESULT_AFTER_MS - (Date.now() - quietFrom);
+		const quietMs = this.quietMs - (Date.now() - quietFrom);
 		return armDeadlineTimer(Math.max(0, quietMs), onQuiet);
 	}
-	/** Ask the provider whether the run still lives; throw when it cannot say so in time. */
-	async confirmRunLive(session) {
+	/** Status diagnoses the observation stop; it cannot substitute for a frame or exact result. */
+	async stopQuietObservation(session) {
 		const deadline = new AbortController();
 		const clear = armDeadlineTimer(RETAINED_STATUS_READ_MS, () => deadline.abort(/* @__PURE__ */ new Error(`no status answer within ${RETAINED_STATUS_READ_MS} ms`)));
 		const signal = AbortSignal.any([this.signal, deadline.signal]);
 		let cause;
 		try {
 			const status = await awaitAbortable(Promise.resolve().then(() => session.status({ signal })), signal);
-			if (status !== null && !isTerminalSessionStatus(status)) {
-				this.silenceHandledAt = Date.now();
-				return;
-			}
 			cause = /* @__PURE__ */ new Error(`provider status reads ${status}`);
 		} catch (error) {
 			if (this.signal.aborted) throw error;
@@ -8936,7 +8493,8 @@ var RetainedObservation = class {
 		} finally {
 			clear();
 		}
-		throw new Error(`retained provider brought no frame or exact result since ${new Date(this.lastObservedAt).toISOString()} and did not confirm its run live`, { cause });
+		if (this.exactResultSettled) return;
+		throw Object.assign(streamFailure("retained provider observation exceeded its quiet interval; exact execution remains pending"), { cause });
 	}
 	async resultFrame() {
 		let result;
@@ -8955,6 +8513,7 @@ var RetainedObservation = class {
 				finalText: result.text,
 				success: result.success,
 				...result.error ? { error: result.error } : {},
+				...result.failure === void 0 ? {} : { failure: result.failure },
 				...result.errorCode ? {
 					errorCode: result.errorCode,
 					statusCode: result.statusCode
@@ -8995,7 +8554,6 @@ var RetainedObservation = class {
 		this.silenceHandledAt = Date.now();
 		return { awaitingResultSince: new Date(since).toISOString() };
 	}
-	/** Read the stream's next frame, or learn first that the wait should publish or the result won. */
 	async raceNextRead(iterator) {
 		let wake;
 		let grace;
@@ -9006,7 +8564,10 @@ var RetainedObservation = class {
 				wake = setImmediate(() => {
 					const close = () => {
 						const flowing = this.sawTerminal ? 0 : RETAINED_TAIL_FLOW_MS - (Date.now() - this.lastObservedAt);
-						if (flowing <= 0) return resolve({ kind: "exact-result" });
+						if (flowing <= 0) {
+							wake = setImmediate(() => resolve({ kind: "exact-result" }));
+							return;
+						}
 						grace = setTimeout(() => {
 							wake = setImmediate(() => resolve({ kind: "exact-result" }));
 						}, flowing);
@@ -9034,7 +8595,6 @@ var RetainedObservation = class {
 			clearQuiet?.();
 		}
 	}
-	/** Bind a frame to its run and drop an exact replay; false when it carries no new evidence. */
 	acceptFrame(event) {
 		this.observedFrames += 1;
 		if (this.exactResultSettled) this.framesAfterResult += 1;
@@ -9076,17 +8636,18 @@ var RetainedObservation = class {
 		this.readExactResult();
 		return true;
 	}
-	/** Yield one subscription's new frames; false when the stream failed rather than ended. */
 	async *drain(session, since) {
+		const subscription = linkAbort(this.signal);
 		let iterator;
 		let failed = false;
 		try {
 			iterator = session.events({
 				executionId: this.handle.controlRef.executionId,
 				...since === void 0 ? {} : { since },
-				signal: this.signal
+				signal: subscription.signal
 			})[Symbol.asyncIterator]();
 		} catch (error) {
+			subscription.abort();
 			if (this.signal.aborted) throw error;
 			this.failure = { error };
 			return false;
@@ -9109,8 +8670,11 @@ var RetainedObservation = class {
 					break;
 				}
 				if (observed.kind === "quiet") {
-					if (this.silenceHandledAt !== void 0) await this.confirmRunLive(session);
-					else yield this.awaitingResult(this.lastObservedAt);
+					if (this.silenceHandledAt !== void 0) await this.stopQuietObservation(session);
+					else {
+						yield this.awaitingResult(this.lastObservedAt);
+						this.lastObservedAt = Date.now();
+					}
 					continue;
 				}
 				if (observed.kind === "exact-result") {
@@ -9119,9 +8683,14 @@ var RetainedObservation = class {
 				}
 				this.pendingRead = void 0;
 				if (observed.value.done) break;
-				if (this.acceptFrame(observed.value.value)) yield observed.value.value;
+				if (this.acceptFrame(observed.value.value)) {
+					yield observed.value.value;
+					this.lastObservedAt = Date.now();
+				}
 			}
 		} finally {
+			subscription.abort();
+			this.pendingRead = void 0;
 			Promise.resolve().then(() => iterator?.return?.()).catch(() => void 0);
 		}
 		return !failed;
@@ -9411,7 +8980,6 @@ var ProviderTurnObserver = class {
 				};
 				continue;
 			}
-			this.args.scope.mirrors.noteProviderEvent();
 			this.archive.append(event);
 			this.text += textFromEnvironmentEvent(event);
 			const sandboxEvent = sandboxEventFromEnvironmentEvent(event);
@@ -9441,10 +9009,6 @@ var ProviderTurnObserver = class {
 // src/runtime/environment-provider/provider-sandbox-adapter.ts
 /** Expose a neutral provider through the existing Sandbox client port. @experimental */
 function providerAsSandboxClient(provider, options = {}) {
-	if (options.workspaceRetention !== void 0) {
-		assertProviderWorkspaceRetentionPort(options.workspaceRetention, `providerAsSandboxClient(${provider.name})`);
-		if (options.retentionIdentity === void 0) throw new ValidationError("providerAsSandboxClient: retentionIdentity is required with workspaceRetention");
-	}
 	return { async create(createOptions) {
 		const defaults = options.defaults ?? {};
 		const sandboxInput = createInputFromSandboxOptions(createOptions, options.mapCreateOptions !== void 0);
@@ -9488,15 +9052,12 @@ function providerAsSandboxClient(provider, options = {}) {
 		if (options.requireSession && (!capabilities?.streaming.live || !capabilities.sessions.continue)) throw new ValidationError(`providerAsSandboxClient(${provider.name}): live session continuation is required`);
 		const environment = await provider.create(mapped);
 		if (options.requireSession && !environment.session) {
-			if (options.workspaceRetention === void 0) await environment.destroy?.();
+			await environment.destroy?.();
 			throw new ValidationError(`providerAsSandboxClient(${provider.name}): session() is required`);
 		}
 		return environmentAsSandboxInstance(environment, {
 			...typeof mapped.profile === "string" ? {} : { profile: mapped.profile },
-			requireTerminalEvent: options.requireTerminalEvent ?? true,
-			workspaceRetention: options.workspaceRetention,
-			retentionIdentity: options.retentionIdentity,
-			onWorkspaceCaptured: options.onWorkspaceCaptured
+			requireTerminalEvent: options.requireTerminalEvent ?? true
 		});
 	} };
 }
@@ -9564,18 +9125,6 @@ function createInputFromSandboxOptions(options, customMapping) {
 	};
 }
 function environmentAsSandboxInstance(environment, options) {
-	let providerSessionId = null;
-	let controlRef;
-	const noteControlRef = (candidate) => {
-		if (options.workspaceRetention === void 0) return;
-		const parsed = AgentExactRunControlRefSchema.safeParse(candidate);
-		if (!parsed.success) return;
-		if (parsed.data.environmentId !== environment.id || parsed.data.provider !== environment.provider) throw new ValidationError("providerAsSandboxClient: capture control reference names another environment");
-		controlRef = freezeControlRef(parsed.data);
-		providerSessionId = controlRef.sessionId;
-	};
-	let capture;
-	let publication;
 	return {
 		id: environment.id,
 		name: environment.name,
@@ -9586,8 +9135,6 @@ function environmentAsSandboxInstance(environment, options) {
 		async *streamPrompt(message, promptOptions) {
 			let terminal = false;
 			const input = turnInputFromPrompt(message, promptOptions, options.profile);
-			providerSessionId = input.sessionId ?? null;
-			noteControlRef(input.controlRef);
 			let cancellation;
 			let cancellationStarted = false;
 			let cancellationFailed = false;
@@ -9648,8 +9195,6 @@ function environmentAsSandboxInstance(environment, options) {
 			let terminal = false;
 			const failures = createProviderFailureLedger();
 			const input = turnInputFromPrompt(message, promptOptions, options.profile);
-			providerSessionId = input.sessionId ?? null;
-			noteControlRef(input.controlRef);
 			for await (const event of environment.stream(input)) {
 				lastResultText = resultTextFromData(event.data) ?? lastResultText;
 				if (isTerminalEnvironmentEvent(event)) terminal = true;
@@ -9676,11 +9221,9 @@ function environmentAsSandboxInstance(environment, options) {
 		...environment.dispatch && environment.session ? { async dispatchPrompt(message, promptOptions) {
 			const session = await environment.dispatch?.(turnInputFromPrompt(message, promptOptions, options.profile));
 			if (!session) throw new ValidationError("providerAsSandboxClient: dispatch returned no session");
-			noteControlRef(session.controlRef);
 			return sandboxDispatchResultFromSessionRef(session);
 		} } : {},
 		...environment.session ? { session(id, sessionOptions) {
-			noteControlRef(sessionOptions?.controlRef);
 			return sandboxSessionFromAgentSession(environment.session?.(id, sessionOptions), sessionOptions?.controlRef, options.profile);
 		} } : {},
 		...environment.read ? { read: environment.read.bind(environment) } : {},
@@ -9699,38 +9242,6 @@ function environmentAsSandboxInstance(environment, options) {
 			return environmentAsSandboxInstance(forked, options);
 		} } : {},
 		async delete() {
-			if (options.workspaceRetention !== void 0) {
-				const identity = options.retentionIdentity;
-				if (identity === void 0) throw new ValidationError("providerAsSandboxClient: retention identity missing before delete");
-				capture ??= captureProviderWorkspaceSnapshot(options.workspaceRetention, {
-					environment,
-					executionId: identity.executionId,
-					...controlRef === void 0 ? {} : { controlRef },
-					...identity.node === void 0 ? {} : { node: identity.node },
-					providerSessionId,
-					nativeSessionId: null,
-					profile: identity.profile
-				}).then((captured) => workspaceCaptureReceipt({
-					environment,
-					executionId: identity.executionId,
-					...controlRef === void 0 ? {} : { controlRef },
-					...identity.node === void 0 ? {} : { node: identity.node },
-					profile: identity.profile,
-					providerSessionId
-				}, captured));
-				const receipt = await capture;
-				publication ??= Promise.resolve().then(async () => {
-					await options.onWorkspaceCaptured?.(receipt);
-				});
-				const publishing = publication;
-				try {
-					await publishing;
-				} catch (error) {
-					if (publication === publishing) publication = void 0;
-					throw error;
-				}
-				if (options.workspaceRetention.requireCompleteProvenance && !receipt.coverageComplete) throw new Error(receipt.incompleteReason ?? "provider workspace retention coverage incomplete");
-			}
 			await environment.destroy?.();
 		}
 	};
@@ -9884,7 +9395,6 @@ var ProviderTurnSettlement = class {
 	args;
 	environment;
 	retained;
-	sessionId;
 	observer;
 	usage;
 	started;
@@ -9896,14 +9406,11 @@ var ProviderTurnSettlement = class {
 	failed = false;
 	/** Set when the turn was refused for capacity and the caller will continue in this environment. */
 	unavailable;
-	/** Whether the final session copy was taken before the workspace capture was handed to the owner. */
-	finalCopyTaken = false;
 	harnessStop;
-	constructor(args, environment, retained, sessionId, observer, usage, started) {
+	constructor(args, environment, retained, observer, usage, started) {
 		this.args = args;
 		this.environment = environment;
 		this.retained = retained;
-		this.sessionId = sessionId;
 		this.observer = observer;
 		this.usage = usage;
 		this.started = started;
@@ -9918,54 +9425,18 @@ var ProviderTurnSettlement = class {
 			durationMs: Date.now() - this.started
 		};
 	}
-	/**
-	* Whether this turn's owner takes its workspace capture over, so the turn ends without waiting
-	* for it: the owner awaits it before the environment's next turn and before destroying the
-	* environment, and journals its receipt. Only a port that copies the session on its own queue
-	* hands it over; without one the capture is the only record of the session.
-	*/
-	ownerTakesCapture() {
-		const { args } = this;
-		return args.options.workspaceRetention?.captureNative !== void 0 && args.createProfile.harness !== void 0 && this.retained && args.retention?.preserveEnvironment === true && args.retention.onEndOfTurnWork !== void 0;
-	}
-	captureReceipt(snapshot) {
-		return providerWorkspaceCaptureReceipt(this.args, this.environment, snapshot, this.sessionId);
-	}
-	/** Hand the workspace capture to the owner. Its receipt reaches the journal as evidence of this
-	*  invocation; a capture that fails leaves none, and the owner's release then keeps the source. */
-	handCaptureToOwner(reported, captureOutcome, settled) {
-		const { args, environment } = this;
-		this.finalCopyTaken = true;
-		args.retention?.onEndOfTurnWork?.((async () => {
-			const copy = settled ? args.scope.mirrors.finishNativeMirror(environment, "settled").catch(() => void 0) : Promise.resolve();
-			let snapshot;
-			try {
-				snapshot = await args.captureWorkspace(environment, captureOutcome);
-			} finally {
-				await copy;
-			}
-			if (settled) args.onPublishedSnapshot(snapshot);
-			if (snapshot === void 0) return;
-			await args.retention?.onEvidence?.({
-				...reported,
-				workspaceSnapshot: snapshot,
-				workspaceCapture: this.captureReceipt(snapshot)
-			});
-		})().catch(() => void 0));
-	}
 	stopEndedHarness() {
 		const { signal } = this.args;
 		if (this.settled !== void 0 || !signal.aborted) return Promise.resolve();
 		this.harnessStop ??= this.args.scope.nativeControl.stopEndedHarness(signal);
 		return this.harnessStop;
 	}
-	/** Retention captures once and exposes that archive through the transcript port; otherwise read live. */
+	/** Read the provider transcript while its environment is still available. */
 	async readLiveTranscript() {
 		const { args } = this;
-		if (args.options.workspaceRetention !== void 0) return;
 		args.scope.state.harnessTranscript = await captureHarnessTranscript(this.environment, args.profile.harness, args.signal);
 	}
-	/** Settle the turn whose events were all read: spend, validator verdict, capture and journal. */
+	/** Commit the consumed turn, validator verdict and measured spend. */
 	async *settle() {
 		const { args, usage } = this;
 		yield* usage.settleTurn();
@@ -9989,38 +9460,14 @@ var ProviderTurnSettlement = class {
 			}),
 			signal: args.signal
 		});
-		const deferCapture = this.ownerTakesCapture();
-		/**
-		* A capture that fails or exceeds its deadline after settlement is a fact about the evidence,
-		* never the turn's outcome. On Runtime 0.295.4 a capture past its 1,200,000 ms
-		* deadline behind a two-slot queue shared by 34 workers threw an AbortError, the driver
-		* classified it terminal, and two research roots ended with 13 and 0 children settled. With no
-		* receipt the source stays preserved and the owner reads a retention failure; the turn is not re-run.
-		*/
-		let retainedWorkspace;
-		let workspaceCaptureFailure;
-		if (!deferCapture) {
-			try {
-				retainedWorkspace = await args.captureWorkspace(this.environment, outcome);
-			} catch (error) {
-				workspaceCaptureFailure = `${errorText(error instanceof Error ? error.message : error)}; source environment preserved`;
-			}
-			args.onPublishedSnapshot(retainedWorkspace);
-		}
-		const settledResult = {
-			...result,
-			...workspaceCaptureFailure === void 0 ? {} : { workspaceCaptureFailure },
-			...retainedWorkspace === void 0 ? {} : {
-				workspaceSnapshot: retainedWorkspace,
-				workspaceCapture: this.captureReceipt(retainedWorkspace)
-			}
-		};
+		const settledResult = result;
 		const jsonOutput = args.options.outputFormat === "json";
 		if (jsonOutput) await args.retention?.onEvidence?.(settledResult);
 		const output = jsonOutput && outcome?.status !== "failed" ? jsonResultFromEvents(result.events) : { out: settledResult };
 		const statusCode = failureStatusCode(outcome);
 		const nativeFailure = outcome?.status === "failed" ? {
 			success: false,
+			...outcome.failure === void 0 ? {} : { failure: outcome.failure },
 			...outcome.error ? { error: outcome.error } : {},
 			...outcome.errorCode ? { errorCode: outcome.errorCode } : {},
 			...statusCode === void 0 ? {} : { statusCode }
@@ -10041,57 +9488,28 @@ var ProviderTurnSettlement = class {
 			});
 			if (signal !== void 0) this.unavailable = {
 				signal,
-				cause: errorText(nativeFailure.error ?? "")
+				cause: errorText(nativeFailure.error ?? ""),
+				...nativeFailure.failure ? { failure: nativeFailure.failure } : {}
 			};
 		}
 		if (this.retained) await args.retention?.onResult(settled);
-		else if (retainedWorkspace !== void 0 && !jsonOutput) await args.retention?.onEvidence?.(settledResult);
 		args.scope.state.pending = false;
 		args.scope.state.artifact = settled;
-		if (deferCapture) this.handCaptureToOwner(settledResult, outcome, true);
 	}
 	/** Record the turn's failure, then capture what evidence its environment still holds. */
 	async *fail(error) {
-		const { args, environment } = this;
+		const { args } = this;
 		yield* this.usage.settleTurn();
 		this.failure = this.retained ? new RetainedExecutionPendingError(error) : error;
 		this.failed = true;
-		if (args.options.workspaceRetention !== void 0) args.scope.state.workspacePreservationRequired = true;
-		const failureOutcome = this.observer.failures.finish() ?? {
-			success: false,
-			status: "failed",
-			error: error instanceof Error ? error.message : String(error),
-			...args.signal.aborted ? { errorCode: "cancelled" } : {}
-		};
 		await this.stopEndedHarness();
-		if (args.signal.aborted) await args.scope.mirrors.finishNativeMirror(environment, "failed");
 		args.scope.state.settleTranscript();
-		if (this.ownerTakesCapture()) {
-			if (!args.signal.aborted) await args.scope.mirrors.finishNativeMirror(environment, "failed");
-			this.handCaptureToOwner({
-				...resultFromEvents(this.observer.archive.events(), this.observer.text),
-				outcome: failureOutcome
-			}, failureOutcome, false);
-		} else try {
-			const retainedWorkspace = await args.captureWorkspace(this.environment, failureOutcome);
-			if (retainedWorkspace !== void 0 && args.retention?.onEvidence !== void 0) await args.retention.onEvidence({
-				...resultFromEvents(this.observer.archive.events(), this.observer.text),
-				outcome: failureOutcome,
-				workspaceSnapshot: retainedWorkspace,
-				workspaceCapture: this.captureReceipt(retainedWorkspace)
-			});
-		} catch (captureError) {
-			if (!(captureError instanceof Error) || captureError === error) this.failure = captureError;
-			else if (captureError.cause === void 0) this.failure = Object.assign(captureError, { cause: this.failure });
-			else this.failure = new AggregateError([captureError, this.failure], captureError.message, { cause: captureError });
-		}
 		await this.readLiveTranscript();
 	}
-	/** Runs on every way the turn ends: the last session copy, then the environment's fate. */
+	/** Stop the harness when required, then settle its environment's custody. */
 	async release() {
 		const { args } = this;
 		await this.stopEndedHarness();
-		if (!this.finalCopyTaken) await args.scope.mirrors.finishNativeMirror(this.environment, this.failed ? "failed" : this.settled !== void 0 ? "settled" : "interrupted");
 		const held = this.retained && this.settled !== void 0 && !this.failed && this.unavailable === void 0 && args.retention?.preserveEnvironment !== true && args.retention?.holdOnSettle?.(this.settled.spent) === true;
 		if (held) args.scope.state.holdingForContinuation = true;
 		if ((!this.retained || this.settled !== void 0 && !this.failed) && !(this.retained && args.retention?.preserveEnvironment) && !(this.unavailable !== void 0 && !this.failed) && !held && (args.options.destroyOnSettle ?? true)) {
@@ -10301,10 +9719,9 @@ async function* streamProviderExecutor(args) {
 	const source = await providerExecutionSource(args, turn, args.signal);
 	const environment = source.environment;
 	args.onEnvironment(environment);
-	args.scope.mirrors.startNativeMirror(environment);
 	const usage = new ProviderUsageAccount(args, turn.model);
 	const observer = new ProviderTurnObserver(args, usage, source.retained, turn.model);
-	const settlement = new ProviderTurnSettlement(args, environment, source.retained, turn.sessionId ?? null, observer, usage, started);
+	const settlement = new ProviderTurnSettlement(args, environment, source.retained, observer, usage, started);
 	try {
 		yield* observer.consume(source.events);
 		yield* settlement.settle();
@@ -10359,18 +9776,7 @@ function invocationArgs(scope, invocation, signal, carried, executionStartedAt,
 			if (!continued) return adoptEnvironment(scope, env);
 			if (env.id !== state.environment?.id) throw new ValidationError(`providerAsExecutor(${provider.name}): a continuation ran in environment ${env.id}, not ${state.environment?.id ?? "<none>"}`);
 			state.environment = env;
-		},
-		onPublishedSnapshot: (snapshot) => {
-			state.workspacePublishedSnapshot = snapshot;
-			if (continued && snapshot !== void 0 && (!options.workspaceRetention?.requireCompleteProvenance || state.workspaceCoverageComplete)) state.workspacePreservationRequired = false;
-		},
-		captureWorkspace: (next, outcome) => captureExecutorWorkspace(scope, next, outcome),
-		workspaceControlRef: () => state.workspaceControlRef,
-		workspaceProvenance: () => state.workspaceProvenance,
-		workspaceCoverage: () => ({
-			complete: state.workspaceCoverageComplete,
-			incompleteReason: state.workspaceIncompleteReason
-		})
+		}
 	};
 }
 /**
@@ -10380,12 +9786,8 @@ function invocationArgs(scope, invocation, signal, carried, executionStartedAt,
 * resolving its unreceipted source.
 */
 function beginWorkspaceExecution(scope) {
-	const { state, options, provider } = scope;
+	const { state, provider } = scope;
 	if (state.workspaceRunActive) throw new ValidationError(`providerAsExecutor(${provider.name}): executor is already running`);
-	if (options.workspaceRetention !== void 0) {
-		if (state.workspacePreservationRequired) throw new ValidationError(`providerAsExecutor(${provider.name}): a prior failed execution has no retrievable workspace receipt; source remains preserved and this executor cannot be reused`);
-		if (state.environment !== void 0 && !state.destroyed) throw new ValidationError(`providerAsExecutor(${provider.name}): the prior workspace environment is still live; teardown must release it before this executor can be reused`);
-	}
 	if (runtimeOwnedExecutorMaterialization(scope.executor()) !== void 0) throw new ValidationError(`providerAsExecutor(${provider.name}): this executor has already materialized; create a new executor for another run`);
 	if (state.environment !== void 0 && state.destroyed) {
 		state.environment = void 0;
@@ -10401,7 +9803,7 @@ function beginWorkspaceExecution(scope) {
 * same environment after the upstream refused a turn for capacity.
 */
 async function* runProviderExecution(scope, task, signal, recovering = false) {
-	const { state, options, retention } = scope;
+	const { state, retention } = scope;
 	beginWorkspaceExecution(scope);
 	const linked = linkAbort(scope.ctx.signal, signal, scope.controller.signal);
 	state.runSignal = linked.signal;
@@ -10425,7 +9827,6 @@ async function* runProviderExecution(scope, task, signal, recovering = false) {
 				state.resetWorkspace(state.environment, invocation.executionId);
 				state.workspaceControlRef = void 0;
 				state.providerSessionId = null;
-				state.workspacePreservationRequired = options.workspaceRetention !== void 0;
 			}
 			const ended = yield* streamProviderExecutor(invocationArgs(scope, invocation, linked.signal, carried, executionStartedAt, continued));
 			const next = await pauseForContinuation(scope, invocation, ended, attempt, refusalsInARow, linked.signal);
@@ -10445,9 +9846,11 @@ async function pauseForContinuation(scope, invocation, ended, attempt, refusalsB
 	const { state, options, provider } = scope;
 	const refusal = ended.unavailable;
 	const continueInvocation = invocation.retention?.continueInvocation;
-	if (refusal === void 0 || continueInvocation === void 0 || state.workspacePreservationRequired || state.workspaceCaptureFailure !== void 0) return;
+	if (refusal === void 0 || continueInvocation === void 0 || state.workspacePreservationRequired) return;
 	const refusalsInARow = ended.madeProgress ? 1 : refusalsBefore + 1;
-	const pauseMs = unavailablePauseMs(refusalsInARow, options.unavailablePause || {});
+	const now = Date.now();
+	const reset = unavailableResumeAt(reportedResetAt(refusal, now), now);
+	const pauseMs = reset === void 0 ? unavailablePauseMs(refusalsInARow, options.unavailablePause || {}) : Math.max(1e3, reset - now);
 	await invocation.retention?.onPause?.({
 		attempt,
 		signal: refusal.signal,
@@ -10496,18 +9899,9 @@ var ProviderExecutorState = class {
 	*  environment is released or handed to the successor node. */
 	holdingForContinuation = false;
 	workspaceEnvironmentId;
-	workspaceSnapshot;
-	workspaceProvenance;
-	workspaceCoverageComplete = false;
-	workspaceIncompleteReason;
-	workspacePublishedSnapshot;
-	workspaceCaptureFailure;
-	workspaceCapturePromise;
 	workspaceCleanupPromise;
 	retainedReleasePromise;
 	releaseReadTried = false;
-	releaseNativeTried = false;
-	workspaceOutcome;
 	workspacePreservationRequired = false;
 	workspaceRunActive = false;
 	providerSessionId = null;
@@ -10529,16 +9923,8 @@ var ProviderExecutorState = class {
 	}
 	/** Forget the capture generation: the next one owns its own snapshot, receipts and verdicts. */
 	clearWorkspaceCapture() {
-		this.workspaceSnapshot = void 0;
-		this.workspaceProvenance = void 0;
-		this.workspaceCoverageComplete = false;
-		this.workspaceIncompleteReason = void 0;
-		this.workspacePublishedSnapshot = void 0;
-		this.workspaceCaptureFailure = void 0;
-		this.workspaceCapturePromise = void 0;
 		this.workspaceCleanupPromise = void 0;
 		this.retainedReleasePromise = void 0;
-		this.workspaceOutcome = void 0;
 		this.workspacePreservationRequired = false;
 		this.destroyed = false;
 	}
@@ -10600,9 +9986,87 @@ function providerMaterialization(provider, createProfile, node, executionId, ret
 		}
 	};
 }
+// src/runtime/environment-provider/provider-retention-lifecycle.ts
+function createProviderNativeControl(provider, retention, managerStop, state) {
+	let nativeStop;
+	const cancelRetainedOnManagerStop = (handle) => {
+		if (managerStop === void 0) return;
+		const cancel = () => {
+			if (state.retained !== handle || !state.workspaceRunActive) return;
+			handle.cancel({
+				operationId: `manager-stop:${randomUUID()}`,
+				reason: String(managerStop.reason ?? "the manager stopped")
+			}).catch(() => void 0);
+		};
+		const stop = () => managerStop.reason === "result-accepted" ? void armDeadlineTimer(ACCEPTED_RESULT_GRACE_MS, cancel) : cancel();
+		if (managerStop.aborted) stop();
+		else managerStop.addEventListener("abort", stop, { once: true });
+	};
+	/** Stop the native harness of this executor's retained execution, which local observation ending
+	*  never stops. Undefined when nothing was dispatched. */
+	const stopNativeExecution = () => {
+		if (nativeStop !== void 0) return nativeStop;
+		const controlRef = state.retained?.controlRef ?? admittedControlRef(retention);
+		if (controlRef === void 0) return Promise.resolve(void 0);
+		const stopping = stopRetainedNativeExecution({
+			provider,
+			controlRef,
+			...state.retained === void 0 ? {} : { handle: state.retained },
+			signal: AbortSignal.timeout(NATIVE_STOP_TIMEOUT_MS)
+		}).then((stop) => {
+			if (stop.effect === "cancelled" || stop.effect === "not_live") {
+				state.harnessStopped = true;
+				state.workspacePreservationRequired = false;
+			} else if (nativeStop === stopping) nativeStop = void 0;
+			return stop;
+		});
+		nativeStop = stopping;
+		return stopping;
+	};
+	/** Stop a retained harness when its turn's deadline or explicit cancellation ends it. */
+	const stopEndedHarness = async (signal) => {
+		if (!isDeadlineAbortReason(signal.reason) && !state.cancelledExplicitly()) return;
+		await stopNativeExecution();
+	};
+	/**
+	* A release that keeps an environment keeps its files, never its running harness. The root has
+	* settled and no process will reconcile this execution, so its native process stops before the
+	* release records what it kept.
+	*/
+	const withoutRunningHarness = (release) => async (signal) => {
+		const stop = await awaitAbortable(stopNativeExecution(), signal).catch(() => void 0);
+		const stopped = stop === void 0 ? "native stop unconfirmed: no exact dispatch or cleanup interrupted" : describeRetainedNativeStops([stop]);
+		const environmentId = (state.retained?.controlRef ?? admittedControlRef(retention))?.environmentId ?? admittedEnvironmentId(retention);
+		if (environmentId !== void 0 && !state.harnessStopped) {
+			state.workspacePreservationRequired = true;
+			return [{
+				provider: provider.name,
+				environmentId,
+				destroyed: false,
+				detail: stopped,
+				permanent: true
+			}];
+		}
+		return (await release(signal)).map((receipt) => receipt.destroyed ? receipt : {
+			...receipt,
+			detail: receipt.detail ? `${receipt.detail}; ${stopped}` : stopped
+		});
+	};
+	return {
+		cancelRetainedOnManagerStop,
+		stopNativeExecution,
+		stopEndedHarness,
+		withoutRunningHarness
+	};
+}
+/** The exact run the latest durable dispatch names, when dispatch got that far. */
+function admittedControlRef(retention) {
+	for (const admission of [...retention?.admissions ?? []].reverse()) if (admission.phase === "dispatched") return admission.controlRef;
+}
+/** Bounds one provider stop: a reconnect, the exact cancellation and its status read. */
+const NATIVE_STOP_TIMEOUT_MS = 3e4;
 // src/runtime/environment-provider/provider-executor-lifecycle.ts
 function createProviderExecutor(provider, profile, ctx, options, placement) {
-	if (options.workspaceRetention !== void 0) assertProviderWorkspaceRetentionPort(options.workspaceRetention, `providerAsExecutor(${provider.name})`);
 	const node = detachedSnapshot(ctx.node, "provider executor node");
 	const retention = retainedExecutorContext(ctx);
 	if (options.outputFormat !== void 0 && (options.outputFormat !== "json" || retention?.onEvidence === void 0 || options.requireTerminalEvent === false)) throw new ValidationError("providerAsExecutor: JSON output requires Runtime-owned durable evidence and a native terminal receipt");
@@ -10627,7 +10091,6 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 		state,
 		controller: new AbortController(),
 		nativeControl: createProviderNativeControl(provider, retention, managerStop, state),
-		mirrors: createProviderCaptureMirrors(options, createProfile, node, state),
 		trace: createPushTraceSource({ runId: executionId }),
 		materialization: providerMaterialization(provider, createProfile, node, executionId, retention, options, placement),
 		continuationTask: LEAF_CONTINUATION_TASK,
@@ -10683,17 +10146,13 @@ async function cancelExecution(scope, request) {
 	};
 }
 async function teardownExecution(scope) {
-	const { state, options } = scope;
+	const { state } = scope;
 	scope.controller.abort();
 	if (state.holdingForContinuation) return {
 		destroyed: false,
 		detail: "environment held for a keyed continuation after a budget stop"
 	};
 	if (state.pending && state.cancelledExplicitly()) scope.nativeControl.stopNativeExecution();
-	if (options.workspaceRetention !== void 0 && state.workspaceRunActive) return {
-		destroyed: false,
-		detail: state.harnessStopped ? "provider workspace retention: source preserved while the stopped execution writes its failure capture" : "provider workspace retention: source preserved while the execution is still active"
-	};
 	if (state.pending) return {
 		destroyed: false,
 		detail: "retained execution requires reconciliation",
@@ -10706,7 +10165,7 @@ function heldEnvironments(scope) {
 	if (state.destroyed) return [];
 	const environmentId = state.environment?.id ?? state.retained?.controlRef.environmentId ?? admittedEnvironmentId(scope.retention);
 	if (environmentId === void 0) return [];
-	const preserved = state.workspacePreservationRequired || state.workspaceCaptureFailure !== void 0;
+	const preserved = state.workspacePreservationRequired;
 	return [{
 		provider: scope.provider.name,
 		environmentId,
@@ -12121,7 +11580,7 @@ const routerInlineExecutor = (spec, ctx) => {
 			const started = Date.now();
 			const linked = linkAbort(signal, controller.signal).signal;
 			recordRuntimeOwnedProviderAttemptStart(executor);
-			const r = await runRouterTransport("routerInlineExecutor", () => seam.tools ? (profileExecution.stream === true ? streamRouterChatWithTools : routerChatWithTools)(routerTransportConfig(seam, model, profileExecution.retry), messages, seam.tools, {
+			const r = await observeModelRequest(executorObservation(ctx), model, () => runRouterTransport("routerInlineExecutor", () => seam.tools ? (profileExecution.stream === true ? streamRouterChatWithTools : routerChatWithTools)(routerTransportConfig(seam, model, profileExecution.retry), messages, seam.tools, {
 				...profileExecution.temperature !== void 0 ? { temperature: profileExecution.temperature } : {},
 				...linked ? { signal: linked } : {},
 				...profileExecution.toolChoice ? { toolChoice: profileExecution.toolChoice } : {},
@@ -12132,7 +11591,7 @@ const routerInlineExecutor = (spec, ctx) => {
 				...linked ? { signal: linked } : {},
 				...routerGenerationOptions(profileExecution),
 				...requestIdentity
-			}));
+			})));
 			if (r.model !== void 0) recordRuntimeOwnedProviderModel(executor, r.model);
 			transcript.reply({
 				content: r.content,
@@ -12614,6 +12073,13 @@ async function executeGranted(env, state, task, external, name, raw, context) {
 		name,
 		arguments: JSON.stringify(args)
 	});
+	const nested = context.callId !== context.parentCallId;
+	if (nested) env.observation?.progress({
+		kind: "tool_call",
+		toolName: name,
+		toolCallId: context.callId,
+		args
+	});
 	const startedAt = Date.now();
 	let status = "ok";
 	try {
@@ -12623,6 +12089,12 @@ async function executeGranted(env, state, task, external, name, raw, context) {
 		throw error;
 	} finally {
 		const endedAt = Date.now();
+		if (nested) env.observation?.progress({
+			kind: "tool_result",
+			toolName: name,
+			toolCallId: context.callId,
+			status
+		});
 		try {
 			seam.onToolStep?.({
 				toolName: name,
@@ -12666,7 +12138,7 @@ async function requestModelTurn(env, state, actions, turn, signal, t) {
 	transcript.observe(state.messages);
 	try {
 		recordRuntimeOwnedProviderAttemptStart(env.executor);
-		const res = await (profileExecution.stream === true ? streamRouterChatWithTools : routerChatWithTools)(routerTransportConfig(seam, env.model, profileExecution.retry), state.messages, actions.presentedTools, {
+		const res = await observeModelRequest(env.observation, env.model, () => (profileExecution.stream === true ? streamRouterChatWithTools : routerChatWithTools)(routerTransportConfig(seam, env.model, profileExecution.retry), state.messages, actions.presentedTools, {
 			...profileExecution.temperature !== void 0 ? { temperature: profileExecution.temperature } : {},
 			signal: turn.controller.signal,
 			onResponse: async (receipt) => {
@@ -12677,7 +12149,7 @@ async function requestModelTurn(env, state, actions, turn, signal, t) {
 			...profileExecution.toolChoice ? { toolChoice: profileExecution.toolChoice } : {},
 			...routerGenerationOptions(profileExecution),
 			...routerTurnRequestIdentity(env.requestIdentity, t)
-		});
+		}));
 		turn.cleanup();
 		return res;
 	} catch (e) {
@@ -12751,12 +12223,27 @@ async function runToolCalls(env, state, actions, turn, external, task, toolCalls
 			name: toolName,
 			arguments: tc?.arguments ?? ""
 		});
+		env.observation?.progress({
+			kind: "tool_call",
+			toolName,
+			toolCallId: id
+		});
 		if (!actions.modelToolNames.has(toolName)) {
 			state.messages.push({
 				role: "tool",
 				tool_call_id: id,
 				content: `error: tool ${JSON.stringify(toolName)} is not enabled by AgentProfile.tools`
 			});
+			env.observation?.progress({
+				kind: "tool_result",
+				toolName,
+				toolCallId: id,
+				status: "error",
+				error: {
+					type: "ToolNotGranted",
+					message: "Tool is not enabled by AgentProfile.tools"
+				}
+			});
 			try {
 				env.seam.onToolStep?.({
 					toolName,
@@ -12775,6 +12262,16 @@ async function runToolCalls(env, state, actions, turn, external, task, toolCalls
 				tool_call_id: id,
 				content: "error: tool arguments were not valid JSON"
 			});
+			env.observation?.progress({
+				kind: "tool_result",
+				toolName,
+				toolCallId: id,
+				status: "error",
+				error: {
+					type: "ToolArguments",
+					message: "Tool arguments were not valid JSON"
+				}
+			});
 			continue;
 		}
 		let result;
@@ -12790,6 +12287,16 @@ async function runToolCalls(env, state, actions, turn, external, task, toolCalls
 			succeeded = false;
 			result = `error: ${e instanceof Error ? e.message : String(e)}`;
 		}
+		env.observation?.progress({
+			kind: "tool_result",
+			toolName,
+			toolCallId: id,
+			status: succeeded ? "ok" : "error",
+			...succeeded ? {} : { error: {
+				type: "ToolExecution",
+				message: String(result)
+			} }
+		});
 		const projected = succeeded && actions.codeMode && toolName === "codemode" ? codeModeModelOutput(result) : void 0;
 		if (projected) images.push(...projected.images);
 		state.messages.push({
@@ -12912,6 +12419,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 		async execute(task, signal) {
 			artifact = await runRouterToolLoop({
 				seam,
+				observation: executorObservation(ctx),
 				spec,
 				model,
 				profileExecution,
@@ -13201,125 +12709,6 @@ const TERMINAL_DECISIONS = [
 function isTerminalDecision(decision) {
 	return TERMINAL_DECISIONS.includes(decision);
 }
-// src/runtime/sandbox-evidence-retention.ts
-/** A failed capture keeps the live source handle available for an explicit retry. */
-var SandboxEvidenceRetentionError = class extends Error {
-	box;
-	constructor(box, cause) {
-		super(`Sandbox evidence retention failed for box ${String(box.id)}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-		this.name = "SandboxEvidenceRetentionError";
-		this.box = box;
-	}
-};
-/** Capture, verify, durably record, then destroy. A failure leaves the source intact. */
-async function captureBeforeDestroy(port, context, destroy) {
-	const environment = {
-		id: String(context.box.id),
-		provider: "sandbox"
-	};
-	const result = await captureProviderWorkspaceSnapshot({
-		timeoutMs: port.timeoutMs,
-		...port.limits === void 0 ? {} : { limits: port.limits },
-		artifacts: port.artifacts,
-		capture: ({ signal }) => port.capture({
-			...context,
-			signal
-		})
-	}, {
-		environment,
-		executionId: context.executionId,
-		providerSessionId: context.sandboxSessionIds[0] ?? null,
-		nativeSessionId: null,
-		profile: context.profile
-	});
-	const missing = context.sandboxSessionIds.filter((id) => !result.provenance.sessions?.some((session) => session.id === id && session.executionId === context.executionId));
-	for (const nativeId of context.nativeSessionIds ?? []) if (!result.provenance.sessions?.some((session) => session.nativeSessionId === nativeId)) missing.push(`native/${nativeId}`);
-	for (const sessionId of context.sandboxSessionIds) if ((context.sessionExecutionIds[sessionId]?.length ?? 0) === 0) missing.push(`${sessionId}/execution-id-unobserved`);
-	for (const [sessionId, executionIds] of Object.entries(context.sessionExecutionIds)) {
-		const session = result.provenance.sessions?.find((item) => item.id === sessionId);
-		for (const executionId of executionIds) if (!session?.executionIds?.includes(executionId) || !session.eventCountsByExecutionId?.[executionId]) missing.push(`${sessionId}/${executionId}`);
-	}
-	const coverageComplete = result.coverageComplete === true && missing.length === 0;
-	const incompleteReason = coverageComplete ? void 0 : [result.incompleteReason, ...missing.map((id) => `Sandbox session ${id} missing from capture`)].filter((reason) => reason !== void 0).join("; ");
-	const receipt = {
-		boxId: String(context.box.id),
-		executionId: context.executionId,
-		profileDigest: canonicalAgentProfileDigest(context.profile),
-		scope: "box",
-		sandboxSessionIds: [...context.sandboxSessionIds],
-		...context.nativeSessionIds === void 0 ? {} : { nativeSessionIds: [...context.nativeSessionIds] },
-		sessionExecutionIds: Object.fromEntries(Object.entries(context.sessionExecutionIds).map(([id, executions]) => [id, [...executions]])),
-		snapshot: result.snapshot,
-		provenance: result.provenance,
-		coverageComplete,
-		...incompleteReason === void 0 ? {} : { incompleteReason }
-	};
-	await port.record(receipt);
-	if (!coverageComplete) throw new Error(incompleteReason ?? "Sandbox evidence coverage incomplete");
-	await destroy();
-	return receipt;
-}
-/** Execution-scoped inventory of every Sandbox session and turn observed by a loop. */
-var SandboxEvidenceTracker = class {
-	port;
-	runId;
-	boxes = /* @__PURE__ */ new Map();
-	constructor(port, runId) {
-		this.port = port;
-		this.runId = runId;
-		if (!Number.isSafeInteger(port.timeoutMs) || port.timeoutMs <= 0) throw new ValidationError$1("Sandbox evidence retention.timeoutMs must be a positive safe integer");
-		if (typeof port.artifacts?.read !== "function") throw new ValidationError$1("Sandbox evidence retention.artifacts.read is required");
-		if (typeof port.capture !== "function") throw new ValidationError$1("Sandbox evidence retention.capture is required");
-		if (typeof port.record !== "function") throw new ValidationError$1("Sandbox evidence retention.record is required");
-	}
-	register(box, profile, sessionId) {
-		let state = this.boxes.get(box);
-		if (state === void 0) {
-			state = {
-				profile,
-				sessions: /* @__PURE__ */ new Map()
-			};
-			this.boxes.set(box, state);
-		}
-		if (sessionId !== void 0 && !state.sessions.has(sessionId)) state.sessions.set(sessionId, /* @__PURE__ */ new Set());
-	}
-	recordDispatch(box, sessionId, executionId) {
-		const state = this.boxes.get(box);
-		if (state === void 0) throw new Error("Sandbox evidence dispatched before box registration");
-		const executions = state.sessions.get(sessionId) ?? /* @__PURE__ */ new Set();
-		executions.add(executionId);
-		state.sessions.set(sessionId, executions);
-	}
-	observe(box, event, sessionHint) {
-		const state = this.boxes.get(box);
-		if (state === void 0) throw new Error("Sandbox evidence observed before box registration");
-		const sessionId = typeof event.data.runtimeSessionId === "string" ? event.data.runtimeSessionId : sessionHint;
-		if (sessionId === void 0) return;
-		const executions = state.sessions.get(sessionId) ?? /* @__PURE__ */ new Set();
-		if (typeof event.data.executionId === "string") executions.add(event.data.executionId);
-		state.sessions.set(sessionId, executions);
-	}
-	async destroy(box) {
-		const state = this.boxes.get(box);
-		if (state === void 0) throw new Error(`Sandbox evidence has no registered source ${String(box.id)}`);
-		const sandboxSessionIds = [...state.sessions.keys()].sort();
-		const sessionExecutionIds = Object.fromEntries([...state.sessions.entries()].map(([id, executions]) => [id, [...executions].sort()]));
-		try {
-			await captureBeforeDestroy(this.port, {
-				box,
-				executionId: this.runId,
-				profile: state.profile,
-				sandboxSessionIds,
-				sessionExecutionIds
-			}, async () => {
-				await box.delete();
-			});
-			this.boxes.delete(box);
-		} catch (error) {
-			throw new SandboxEvidenceRetentionError(box, error);
-		}
-	}
-};
 // src/runtime/sandbox-acquire.ts
 /**
 * HTTP statuses where create should be retried — gateway timeouts
@@ -13364,20 +12753,14 @@ async function acquireSandbox(client, options, acquire = {}) {
 	while (now() < deadline) {
 		throwIfAborted(acquire.signal);
 		try {
-			const box = await client.create(createOpts, acquire.signal === void 0 ? void 0 : { signal: acquire.signal });
-			acquire.onAcquire?.(box);
-			return await waitReadyOrDestroy(box, deadline, pollMs, acquire.signal, now, sleep$1, acquire.beforeDelete);
+			return await waitReadyOrDestroy(await client.create(createOpts, acquire.signal === void 0 ? void 0 : { signal: acquire.signal }), deadline, pollMs, acquire.signal, now, sleep$1);
 		} catch (err) {
-			if (err instanceof SandboxEvidenceRetentionError) throw err;
 			throwIfAborted(acquire.signal);
 			if (!isRetryable(err)) throw err;
 			lastErr = err;
 			if (typeof c.list === "function") for (let scan = 0; scan < appearScans && now() < deadline; scan += 1) {
 				const found = (await c.list().catch(() => []))?.find((b) => b.name === name);
-				if (found) {
-					acquire.onAcquire?.(found);
-					return await waitReadyOrDestroy(found, deadline, pollMs, acquire.signal, now, sleep$1, acquire.beforeDelete);
-				}
+				if (found) return await waitReadyOrDestroy(found, deadline, pollMs, acquire.signal, now, sleep$1);
 				if (scan < 4) await sleep$1(pollMs);
 			}
 			attempt += 1;
@@ -13388,12 +12771,11 @@ async function acquireSandbox(client, options, acquire = {}) {
 }
 /** `waitUntilReady`, tearing the box down (best-effort) on any throw so a box
 *  that never reaches `running` (abort, terminal status, budget) does not leak. */
-async function waitReadyOrDestroy(box, deadline, pollMs, signal, now, sleep, beforeDelete) {
+async function waitReadyOrDestroy(box, deadline, pollMs, signal, now, sleep) {
 	try {
 		return await waitUntilReady(box, deadline, pollMs, signal, now, sleep);
 	} catch (err) {
-		if (beforeDelete === void 0) await deleteBoxSafe(box);
-		else await beforeDelete(box);
+		await deleteBoxSafe(box);
 		throw err;
 	}
 }
@@ -13575,14 +12957,9 @@ function createSandboxLineage(client, options = {}) {
 	const profiles = /* @__PURE__ */ new Map();
 	const acquireFresh = async (spec, signal) => {
 		if (signal.aborted) throwAbort();
-		const box = await acquireSandbox(client, buildBackendOptions(spec.profile, spec.sandboxOverrides), {
-			signal,
-			...options.onAcquire === void 0 ? {} : { onAcquire: (source) => options.onAcquire?.(source, spec.profile) },
-			...options.beforeDelete === void 0 ? {} : { beforeDelete: options.beforeDelete }
-		});
+		const box = await acquireSandbox(client, buildBackendOptions(spec.profile, spec.sandboxOverrides), { signal });
 		owned.push(box);
 		profiles.set(box, spec.profile);
-		options.onAcquire?.(box, spec.profile);
 		try {
 			await spec.prepareBox?.(box, {
 				signal,
@@ -13590,7 +12967,7 @@ function createSandboxLineage(client, options = {}) {
 			});
 		} catch (error) {
 			try {
-				await destroyBounded(box, options.failOnDestroyError, options.beforeDelete);
+				await destroyBounded(box, options.failOnDestroyError);
 				owned.splice(owned.indexOf(box), 1);
 			} catch (captureError) {
 				throw new AggregateError([error, captureError], "Sandbox preparation and evidence cleanup failed");
@@ -13629,19 +13006,13 @@ function createSandboxLineage(client, options = {}) {
 			if (branched !== void 0) {
 				owned.push(...branched);
 				const inheritedProfile = profiles.get(parent.box);
-				if (inheritedProfile !== void 0) for (const box of branched) {
-					profiles.set(box, inheritedProfile);
-					options.onAcquire?.(box, inheritedProfile);
-				}
+				if (inheritedProfile !== void 0) for (const box of branched) profiles.set(box, inheritedProfile);
 				if (branched.length !== prompts.length) throw new ValidationError$1(`SandboxLineage.fork: Sandbox returned ${branched.length} of ${prompts.length} requested children`);
 				return mapWithConcurrency(branched, forkConcurrency, async (box, i) => {
 					throwIfAborted(signal);
 					const spec = specs[i % specs.length];
 					if (!spec) throw new ValidationError$1("SandboxLineage.fork: no AgentRunSpec for branch");
-					if (inheritedProfile === void 0) {
-						profiles.set(box, spec.profile);
-						options.onAcquire?.(box, spec.profile);
-					}
+					if (inheritedProfile === void 0) profiles.set(box, spec.profile);
 					await spec.prepareBox?.(box, {
 						signal,
 						recordMount
@@ -13678,7 +13049,7 @@ function createSandboxLineage(client, options = {}) {
 			const doomed = [];
 			for (const box of owned) (keepBoxes.has(box) ? survivors : doomed).push(box);
 			if (doomed.length === 0) return;
-			const results = await Promise.allSettled(doomed.map((box) => destroyBounded(box, options.failOnDestroyError, options.beforeDelete)));
+			const results = await Promise.allSettled(doomed.map((box) => destroyBounded(box, options.failOnDestroyError)));
 			const failed = results.flatMap((result, index) => result.status === "rejected" ? [doomed[index]] : []);
 			owned.length = 0;
 			owned.push(...survivors, ...failed);
@@ -13686,7 +13057,7 @@ function createSandboxLineage(client, options = {}) {
 		},
 		async teardown() {
 			const boxes = owned.splice(0, owned.length);
-			const results = await Promise.allSettled(boxes.map((box) => destroyBounded(box, options.failOnDestroyError, options.beforeDelete)));
+			const results = await Promise.allSettled(boxes.map((box) => destroyBounded(box, options.failOnDestroyError)));
 			const failed = results.flatMap((result, index) => result.status === "rejected" ? [boxes[index]] : []);
 			owned.push(...failed);
 			if (failed.length > 0) throw new AggregateError(results.filter((result) => result.status === "rejected").map((result) => result.reason), "Sandbox evidence capture failed before teardown");
@@ -13733,11 +13104,7 @@ async function assertSessionLive(box, sessionId) {
 	if (typeof session !== "function") return;
 	if (await session.call(box, sessionId).status() === null) throw new ValidationError$1(`SandboxLineage.continue: session ${sessionId} is not known to the sandbox — the platform did not preserve the client-minted session id (or it was reaped). Continuing would run without prior context; refusing to silently lose conversation continuity.`);
 }
-async function destroyBounded(box, failOnError = false, beforeDelete) {
-	if (beforeDelete !== void 0) {
-		await beforeDelete(box);
-		return;
-	}
+async function destroyBounded(box, failOnError = false) {
 	if (failOnError) {
 		await box.delete();
 		return;
@@ -13751,7 +13118,7 @@ async function destroyBounded(box, failOnError = false, beforeDelete) {
 * Rejects the lineage + `onWorkerBox` combination: both claim the same
 * box-ownership channel, and silently honoring one would leak or double-free.
 */
-async function setUpLineage(options, maxConcurrency, recordMount, promptOptions, evidenceTracker) {
+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");
@@ -13759,12 +13126,7 @@ async function setUpLineage(options, maxConcurrency, recordMount, promptOptions,
 		lineage: createSandboxLineage(options.ctx.sandboxClient, {
 			maxConcurrency,
 			streaming: lineageOpts.streaming,
-			recordMount,
-			...evidenceTracker === void 0 ? {} : {
-				failOnDestroyError: true,
-				onAcquire: (box, profile) => evidenceTracker.register(box, profile),
-				beforeDelete: (box) => evidenceTracker.destroy(box)
-			}
+			recordMount
 		}),
 		options: lineageOpts,
 		...promptOptions === void 0 ? {} : { promptOptions },
@@ -13785,12 +13147,7 @@ async function setUpLineage(options, maxConcurrency, recordMount, promptOptions,
 * Round 0 (parentIndex undefined) always starts fresh — the independence of the
 * first batch is preserved.
 */
-function planLineageRound(state, specs, slice, parentIndex, signal, retainEvidence) {
-	const executionIds = retainEvidence ? slice.map(() => randomUuid()) : [];
-	const promptForOffset = (offset) => retainEvidence ? {
-		...state.promptOptions ?? {},
-		executionId: executionIds[offset]
-	} : state.promptOptions;
+function planLineageRound(state, specs, slice, parentIndex, signal) {
 	const lineage = state.lineage;
 	const parent = parentIndex !== void 0 ? state.handles.get(parentIndex) : void 0;
 	const promptFor = (offset) => {
@@ -13805,9 +13162,8 @@ function planLineageRound(state, specs, slice, parentIndex, signal, retainEviden
 	};
 	if (slice.length === 1 && parent && state.options.sessionContinuity) return [{ async acquire() {
 		return {
-			events: await lineage.continue(parent, promptFor(0), signal, promptForOffset(0)),
-			handle: parent,
-			...retainEvidence ? { executionId: executionIds[0] } : {}
+			events: await lineage.continue(parent, promptFor(0), signal, state.promptOptions),
+			handle: parent
 		};
 	} }];
 	if (slice.length > 1 && parent && state.options.forkFanout) {
@@ -13815,23 +13171,17 @@ function planLineageRound(state, specs, slice, parentIndex, signal, retainEviden
 		const childSpecs = slice.map((_, offset) => specAt(offset));
 		let forked;
 		const ensureForked = () => {
-			forked ??= lineage.fork(parent, prompts, childSpecs, signal, state.promptOptions, retainEvidence ? executionIds : void 0);
+			forked ??= lineage.fork(parent, prompts, childSpecs, signal, state.promptOptions);
 			return forked;
 		};
 		return slice.map((_, offset) => ({ async acquire() {
 			const branch = (await ensureForked())[offset];
 			if (!branch) throw new ValidationError$1("runAgentRounds: lineage fork produced no branch for offset");
-			return {
-				...branch,
-				...retainEvidence ? { executionId: executionIds[offset] } : {}
-			};
+			return branch;
 		} }));
 	}
 	return slice.map((_, offset) => ({ async acquire() {
-		return {
-			...await lineage.start(specAt(offset), promptFor(offset), signal, promptForOffset(offset)),
-			...retainEvidence ? { executionId: executionIds[offset] } : {}
-		};
+		return await lineage.start(specAt(offset), promptFor(offset), signal, state.promptOptions);
 	} }));
 }
 /**
@@ -13936,22 +13286,14 @@ function readSandboxId(box) {
 * loop kernel passes its per-run recorder; other callers (which have no
 * `LoopResult` to attach to) omit it and the prepareBox recorder is a no-op.
 */
-async function createSandboxForSpec(client, spec, signal, recordMount, evidenceTracker) {
+async function createSandboxForSpec(client, spec, signal, recordMount) {
 	const opts = buildBackendOptions(spec.profile, spec.sandboxOverrides);
 	if (signal.aborted) throwAbort();
-	const box = await acquireSandbox(client, opts, {
-		signal,
-		...evidenceTracker === void 0 ? {} : {
-			onAcquire: (source) => evidenceTracker.register(source, spec.profile),
-			beforeDelete: (source) => evidenceTracker.destroy(source)
-		}
-	});
-	evidenceTracker?.register(box, spec.profile);
+	const box = await acquireSandbox(client, opts, { signal });
 	try {
 		await invokePrepareBox(spec, box, signal, recordMount);
 	} catch (error) {
-		if (evidenceTracker === void 0) await deleteBoxSafe(box);
-		else await evidenceTracker.destroy(box);
+		await deleteBoxSafe(box);
 		throw error;
 	}
 	return box;
@@ -14039,8 +13381,6 @@ async function executeIteration(args) {
 	};
 	try {
 		let stream;
-		let sandboxSessionId;
-		let dispatchedExecutionId;
 		const source = args.lineagePlan?.[args.item.index - args.baseIndex];
 		if (source) {
 			const acquired = await source.acquire();
@@ -14048,28 +13388,16 @@ async function executeIteration(args) {
 			boxAcquiredAt = args.now();
 			lineageOwned = true;
 			args.lineageState?.handles.set(args.item.index, acquired.handle);
-			args.evidenceTracker?.register(box, spec.profile, acquired.handle.sessionId);
 			stream = acquired.events;
-			sandboxSessionId = acquired.handle.sessionId;
-			dispatchedExecutionId = acquired.executionId;
 		} else {
-			box = await createSandboxForSpec(args.ctx.sandboxClient, spec, args.signal, args.recordMount, args.evidenceTracker);
+			box = await createSandboxForSpec(args.ctx.sandboxClient, spec, args.signal, args.recordMount);
 			boxAcquiredAt = args.now();
 			const prompt = spec.taskToPrompt(args.item.task);
-			const sandboxSessionIdForTurn = args.evidenceTracker === void 0 ? void 0 : randomUuid();
-			sandboxSessionId = sandboxSessionIdForTurn;
-			dispatchedExecutionId = args.evidenceTracker === void 0 ? void 0 : randomUuid();
-			const promptOptions = dispatchedExecutionId === void 0 ? args.promptOptions : {
+			stream = args.streaming === "poll" ? promptEvents("poll", box, prompt, `${args.runId}-i${args.item.index}`, args.signal, args.promptOptions) : box.streamPrompt(prompt, {
 				...args.promptOptions ?? {},
-				executionId: dispatchedExecutionId
-			};
-			stream = args.streaming === "poll" ? promptEvents("poll", box, prompt, sandboxSessionIdForTurn ?? `${args.runId}-i${args.item.index}`, args.signal, promptOptions) : box.streamPrompt(prompt, {
-				...promptOptions ?? {},
-				...sandboxSessionIdForTurn === void 0 ? {} : { sessionId: sandboxSessionIdForTurn },
 				signal: args.signal
 			});
 		}
-		if (box !== void 0 && sandboxSessionId !== void 0 && dispatchedExecutionId !== void 0) args.evidenceTracker?.recordDispatch(box, sandboxSessionId, dispatchedExecutionId);
 		const placement = describeSandboxPlacement(args.ctx.sandboxClient, box);
 		await emitTrace(args.ctx.traceEmitter, {
 			kind: "loop.iteration.dispatch",
@@ -14096,7 +13424,6 @@ async function executeIteration(args) {
 		try {
 			for await (const event of stream) {
 				collector.push(event);
-				if (box !== void 0) args.evidenceTracker?.observe(box, event, source ? args.lineageState?.handles.get(args.item.index)?.sessionId : void 0);
 				outcomeTracker.observe(event);
 				notifySandboxEventObserver(event, args.ctx.onSandboxEvent, {
 					iterationIndex: args.item.index,
@@ -14156,7 +13483,7 @@ async function executeIteration(args) {
 		});
 		if (lineageOwned) {} else if (args.collectBox && box) args.collectBox(box);
 		else {
-			const teardown = args.evidenceTracker === void 0 || box === void 0 ? await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now) : await args.evidenceTracker.destroy(box).then(() => "deleted");
+			const teardown = await destroySandboxSafe(box, args.ctx.traceEmitter, args.runId, args.now);
 			if (boxAcquiredAt !== void 0 && teardown !== "no-delete-api") {
 				slot.boxLiveMs = Math.max(0, args.now() - boxAcquiredAt);
 				if (teardown !== "deleted") slot.boxLiveMsKnown = false;
@@ -14248,8 +13575,6 @@ async function runAgentRounds(options) {
 	const promptOptions = readPromptOptions(options.ctx.promptOptions, "runAgentRounds: ctx.promptOptions");
 	const now = options.now ?? Date.now;
 	const runId = options.runId ?? `loop-${randomSuffix()}`;
-	if (options.evidenceRetention !== void 0 && options.onWorkerBox !== void 0) throw new ValidationError$1("runAgentRounds: evidenceRetention cannot cover sessions dispatched through onWorkerBox");
-	const evidenceTracker = options.evidenceRetention === void 0 ? void 0 : new SandboxEvidenceTracker(options.evidenceRetention, runId);
 	const loopStart = now();
 	const driverName = options.driver.name ?? "driver";
 	const iterations = [];
@@ -14263,7 +13588,7 @@ async function runAgentRounds(options) {
 		ownedBoxes.push(box);
 		options.onWorkerBox?.(box);
 	} : void 0;
-	const lineageState = await setUpLineage(options, maxConcurrency, recordMount, promptOptions, evidenceTracker);
+	const lineageState = await setUpLineage(options, maxConcurrency, recordMount, promptOptions);
 	emitRunLoopHook(options, {
 		target: "agent.run",
 		phase: "before",
@@ -14359,7 +13684,7 @@ async function runAgentRounds(options) {
 					tokenUsage: zeroTokenUsage()
 				});
 			}
-			const lineagePlan = lineageState ? planLineageRound(lineageState, specs, slice, parentIndex, controller.signal, evidenceTracker !== void 0) : void 0;
+			const lineagePlan = lineageState ? planLineageRound(lineageState, specs, slice, parentIndex, controller.signal) : void 0;
 			await runBatch({
 				slice,
 				baseIndex,
@@ -14378,7 +13703,6 @@ async function runAgentRounds(options) {
 				collectBox,
 				lineagePlan,
 				lineageState,
-				evidenceTracker,
 				recordMount,
 				...promptOptions === void 0 ? {} : { promptOptions }
 			});
@@ -14418,7 +13742,7 @@ async function runAgentRounds(options) {
 		return await decideAndFinalize(options, iterations, loopStart, now, runId, mounts);
 	} finally {
 		if (options.ctx.signal) options.ctx.signal.removeEventListener("abort", onOuterAbort);
-		const cleanup = await Promise.allSettled(ownedBoxes.map((box) => evidenceTracker === void 0 ? destroySandboxSafe(box, options.ctx.traceEmitter, runId, now) : evidenceTracker.destroy(box)));
+		const cleanup = await Promise.allSettled(ownedBoxes.map((box) => destroySandboxSafe(box, options.ctx.traceEmitter, runId, now)));
 		if (options.onWorkerBox) options.onWorkerBox(void 0);
 		let lineageFailure;
 		try {
@@ -14477,7 +13801,6 @@ function sandboxSessionOutput(run) {
 		toolCalls: run.toolCalls,
 		...run.latestOutcome ? { outcome: run.latestOutcome } : {},
 		...run.usageFailure === void 0 ? {} : { tokensUnknownReason: run.usageFailure },
-		...run.args.workspaceCaptures === void 0 ? {} : { workspaceCaptures: run.args.workspaceCaptures() },
 		...run.preservationFailure === void 0 ? {} : { preservationFailure: run.preservationFailure }
 	};
 }
@@ -14950,7 +14273,6 @@ function sandboxExecutorForPath(spec, ctx, modelPath) {
 			harness,
 			sandboxClient: seam.sandboxClient,
 			failOnDestroyError: seam.failOnDestroyError,
-			workspaceCaptures: seam.workspaceCaptures,
 			inbox,
 			taskToPrompt: (t) => taskToPrompt$1(t),
 			options: seam.steering,
@@ -14958,8 +14280,6 @@ function sandboxExecutorForPath(spec, ctx, modelPath) {
 			...Object.keys(traceEnv).length > 0 ? { traceEnv } : {},
 			contentRef
 		});
-		const bindCaptureOutput = ctx.seams[sandboxCaptureOutputSeamKey];
-		if (typeof bindCaptureOutput === "function") bindCaptureOutput(() => session.output());
 		return attestRuntimeOwnedExecutor({
 			runtime: "sandbox",
 			deliver: (m) => inbox.deliver(m),
@@ -15195,7 +14515,7 @@ function singleShotDriver(maxIterations) {
 * model, process, limits, or backend behavior is detached and deeply frozen.
 * Explicit service/function fields remain live by reference because they are executable ports,
 * not portable configuration. */
-function snapshotExecutorConfig(config) {
+function snapshotExecutorConfig(config, mode = "execution") {
 	switch (config.backend) {
 		case "router-tools": {
 			const { complete, executeToolCall, onMessages, onToolStep, onProviderResponse, ...decisionData } = config;
@@ -15250,17 +14570,16 @@ function snapshotExecutorConfig(config) {
 		}
 		case "provider": {
 			if (config.outputFormat !== void 0 && config.steering !== void 0) throw new ValidationError$1("createExecutor(provider): JSON output is not supported with steering");
-			const { provider, registry, profileForCreate, taskToTurn, validator, workspaceRetention, shared, ...decisionData } = config;
-			if (shared !== void 0 && (decisionData.steering !== void 0 || decisionData.placements !== void 0 || workspaceRetention !== void 0)) throw new ValidationError$1("createExecutor(provider): shared placement cannot combine with steering, placements, or workspaceRetention");
+			const { provider, registry, profileForCreate, taskToTurn, validator, shared, ...decisionData } = config;
+			if (shared !== void 0 && (decisionData.steering !== void 0 || decisionData.placements !== void 0)) throw new ValidationError$1("createExecutor(provider): shared placement cannot combine with steering or placements");
 			const snapshot = detachedSnapshot(decisionData, "createExecutor provider config");
-			const resolvedProvider = resolveAgentEnvironmentProvider(provider, registry);
+			const resolvedProvider = mode === "control" && typeof provider === "string" ? registry?.get(provider) ?? provider : resolveAgentEnvironmentProvider(provider, registry);
 			return Object.freeze({
 				...snapshot,
 				provider: resolvedProvider,
 				...profileForCreate === void 0 ? {} : { profileForCreate },
 				...taskToTurn === void 0 ? {} : { taskToTurn },
 				...validator === void 0 ? {} : { validator },
-				...workspaceRetention === void 0 ? {} : { workspaceRetention },
 				...shared === void 0 ? {} : { shared }
 			});
 		}
@@ -15268,7 +14587,6 @@ function snapshotExecutorConfig(config) {
 			assertExactConfigKeys(config, /* @__PURE__ */ new Set([
 				"backend",
 				"failOnDestroyError",
-				"workspaceCaptures",
 				"lineage",
 				"loopCtx",
 				"maxIterations",
@@ -15276,11 +14594,10 @@ function snapshotExecutorConfig(config) {
 				"steering",
 				"validator"
 			]), "createExecutor sandbox config");
-			const { sandboxClient, loopCtx, validator, workspaceCaptures, ...decisionData } = config;
+			const { sandboxClient, loopCtx, validator, ...decisionData } = config;
 			const port = {
 				sandboxClient,
-				...validator === void 0 ? {} : { validator },
-				...workspaceCaptures === void 0 ? {} : { workspaceCaptures }
+				...validator === void 0 ? {} : { validator }
 			};
 			if (loopCtx === void 0) {
 				const snapshot = detachedSnapshot(decisionData, "createExecutor sandbox config");
@@ -15408,9 +14725,6 @@ function createExecutor(config) {
 					if (providerSeam.destroyOnSettle === false) throw new ValidationError$1("createExecutor(provider, steering): destroyOnSettle=false conflicts with the session-owned environment lifecycle");
 					if (providerSeam.validator) throw new ValidationError$1("createExecutor(provider, steering): validator is not representable with steering — the steerable session is a multi-turn session on one environment, not a scored single-shot leaf, so the score would be silently dropped");
 					const harness = requiredProviderProfileHarness(spec, providerSeam);
-					const workspaceCaptures = [];
-					let capturedOutput;
-					const publishEvidence = retainedExecutorContext(seamed)?.onEvidence;
 					const sandboxClient = providerAsSandboxClient(provider, {
 						defaults: {
 							...providerSeam.defaults ?? {},
@@ -15418,34 +14732,14 @@ function createExecutor(config) {
 							signal: seamed.signal
 						},
 						requireTerminalEvent: providerSeam.requireTerminalEvent,
-						requireSession: true,
-						...providerSeam.workspaceRetention === void 0 ? {} : {
-							workspaceRetention: providerSeam.workspaceRetention,
-							retentionIdentity: {
-								executionId: seamed.node?.nodeId ?? `provider-run-${randomUUID()}`,
-								profile: spec.profile,
-								...seamed.node === void 0 ? {} : { node: seamed.node }
-							},
-							onWorkspaceCaptured: async (receipt) => {
-								if (!workspaceCaptures.includes(receipt)) workspaceCaptures.push(receipt);
-								if (publishEvidence !== void 0) {
-									if (capturedOutput === void 0) throw new ValidationError$1("provider capture has no bound session output");
-									await publishEvidence(capturedOutput());
-								}
-							}
-						}
+						requireSession: true
 					});
 					const providerCtx = {
 						...seamed,
 						seams: {
 							...seamed.seams,
-							[sandboxCaptureOutputSeamKey]: (read) => {
-								capturedOutput = read;
-							},
 							[sandboxSeamKey]: {
 								sandboxClient,
-								failOnDestroyError: providerSeam.workspaceRetention !== void 0,
-								...providerSeam.workspaceRetention === void 0 ? {} : { workspaceCaptures: () => workspaceCaptures },
 								steering: providerSeam.steering,
 								...providerSeam.promptOptions === void 0 ? {} : { loopCtx: { promptOptions: providerSeam.promptOptions } }
 							}
@@ -15718,13 +15012,11 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 	const unconfirmedDescendants = () => nestedScopeHeld === void 0 ? [] : unconfirmedTeardowns(nestedScopeHeld);
 	const closeActive = (reason) => {
 		if (active === void 0) return Promise.resolve();
-		if (!active.close) {
-			const { scope, controller } = active;
-			active.close = closeNestedScope(scope, controller, reason).then(() => void 0, (error) => {
-				cleanupFailure = error;
-				throw error;
-			});
-		}
+		if (reason !== void 0 && !active.controller.signal.aborted) active.controller.abort(reason);
+		if (!active.close) active.close = closeNestedScope(active.scope).then(() => void 0, (error) => {
+			cleanupFailure = error;
+			throw error;
+		});
 		return active.close;
 	};
 	const rollUp = (events) => {
@@ -15760,9 +15052,11 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 			const ownedSpawn = ownedTreeRootSpawn(parentSpawn);
 			previouslyMetered = recovering ? sumMetered((parentEvents ?? []).filter((event) => event.id === seam.nodeId)) : zeroSpend();
 			await journal.beginTree(nestedRoot, (/* @__PURE__ */ new Date(0)).toISOString());
-			const prior = await journal.loadTree(nestedRoot) ?? [];
-			if (prior.length === 0) await journal.appendEvent(nestedRoot, ownedSpawn);
-			else if (contentAddress(prior[0]) !== contentAddress(ownedSpawn)) throw new ValidationError$1("driverExecutor: nested recovery changed its owning parent spawn");
+			let prior = await journal.loadTree(nestedRoot) ?? [];
+			if (prior.length === 0) {
+				await journal.appendEvent(nestedRoot, ownedSpawn);
+				prior = [ownedSpawn];
+			} else if (contentAddress(prior[0]) !== contentAddress(ownedSpawn)) throw new ValidationError$1("driverExecutor: nested recovery changed its owning parent spawn");
 			else if (prior.length !== 1 && !recovering) throw new RetainedExecutionPendingError(new ValidationError$1("driverExecutor: interrupted nested execution requires recovery"), "nested-recovery");
 			if (recovering && (!spec.recoverExecutor || !seam.restore)) throw new RetainedExecutionPendingError(new ValidationError$1("driverExecutor: nested recovery has no original executor reconstruction"), "nested-recovery");
 			signal.throwIfAborted();
@@ -15797,8 +15091,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 				}
 				const out = await runAbortable(() => driver.act(task, nestedScope), controller.signal, "driver aborted");
 				await finalizeScopeOwnerMaterialization(nestedScope);
-				await closeActive("driver completed");
-				releaseManagerEnvironment(nestedScope).catch(() => void 0);
+				await closeActive();
 				const events = await loadTreeEvents(journal, nestedRoot);
 				const childWork = rollUp(events);
 				const acceptedSubmission = spec.acceptedSubmission?.() === true;
@@ -15899,8 +15192,8 @@ function isTerminalAdmissionRefusal(error) {
 	const failure = error instanceof DriverAttemptsExhaustedError && error.stop === "terminal-error" ? error.cause : error;
 	return (isCredentialRefusal(failure) || failure instanceof RetainedExecutionPendingError && failure.phase === "admission" && failure.pendingCause === "request-rejected") && classifyDriverFailure(failure) === "terminal";
 }
-async function closeNestedScope(scope, controller, reason) {
-	if (!controller.signal.aborted) controller.abort(reason);
+async function closeNestedScope(scope) {
+	closeScopeAdmission(scope);
 	for (;;) if (await scope.next() === null) break;
 	await releaseHeldEnvironments(scope);
 	const view = scope.view;
@@ -15974,38 +15267,6 @@ function readNestedScopeSeam(ctx) {
 function isAgent(value) {
 	return typeof value === "object" && value !== null && typeof value.act === "function" && typeof value.name === "string";
 }
-/** Parent journals may already contain an interrupted driver's inference prefix. */
-function unreportedSpend(total, prior) {
-	const tokens = { ...total.tokens };
-	for (const key of [
-		"input",
-		"output",
-		"freshInput",
-		"cacheRead",
-		"cacheWrite"
-	]) {
-		const value = total.tokens[key];
-		if (value !== void 0) tokens[key] = Math.max(0, value - (prior.tokens[key] ?? 0));
-	}
-	return {
-		...total,
-		...addResourceSpend(total.resources === void 0 ? void 0 : Object.fromEntries(Object.entries(total.resources).map(([name, value]) => {
-			const previous = prior.resources?.[name];
-			if (previous && previous.unit !== value.unit) throw new ValidationError$1(`resource ${name}: unit mismatch`);
-			return [name, {
-				...value,
-				amount: Math.max(0, value.amount - (previous?.amount ?? 0)),
-				known: value.known && (previous?.known ?? true)
-			}];
-		}))),
-		iterations: Math.max(0, total.iterations - prior.iterations),
-		tokens,
-		usd: Math.max(0, total.usd - prior.usd),
-		ms: Math.max(0, total.ms - prior.ms),
-		...total.usdEstimated === void 0 ? {} : { usdEstimated: Math.max(0, total.usdEstimated - (prior.usdEstimated ?? 0)) },
-		...total.boxMinutes === void 0 ? {} : { boxMinutes: Math.max(0, total.boxMinutes - (prior.boxMinutes ?? 0)) }
-	};
-}
 // src/runtime/supervise/supervisor-root-handle.ts
 /** Module-private channel from a minted `RootHandle` to its `RootControl`, so `attach`
 *  can prove a handle is ours and reach its binding without leaking the control onto the
@@ -16844,8 +16105,8 @@ function allSpawnedChildrenDown(tree) {
 }
 function poolExhausted(pool, opts) {
 	const r = pool.readout();
-	if (r.iterationsLeft <= 0) return true;
-	if (r.tokensLeft <= 0) return true;
+	if (r.iterationsCapped !== false && r.iterationsLeft <= 0) return true;
+	if (r.tokensCapped !== false && r.tokensLeft <= 0) return true;
 	return opts.budget.maxUsd !== void 0 && r.usdLeft <= 0;
 }
 function deadlinePassed(pool, opts) {
@@ -17059,7 +16320,7 @@ function guardRunPersistence(journal, blobs, interrupt) {
 /** Read every caller-owned field once, then detach and freeze all decision data before the first
 *  await; stateful collaborators stay live by reference, but later opts mutation cannot redirect the run. */
 function admitSupervisorRun(task, opts) {
-	const { budget, rootIdentity, rootSegment, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, maxDepth, workerSlots, reservationPolicy, deadlineCheckIn, budgetStopHoldMs, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, ownerWorkspaceRetention, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
+	const { budget, rootIdentity, rootSegment, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, recoverExecutor, maxDepth, workerSlots, reservationPolicy, deadlineCheckIn, budgetStopHoldMs, maxRestarts, withinMs, childSettleGraceMs, teardownConfirmMs, resume, retainedAtSettlement: requestedRetainedAtSettlement, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
 	const input = detachedSnapshot({
 		task,
 		options: {
@@ -17077,7 +16338,6 @@ function admitSupervisorRun(task, opts) {
 			...teardownConfirmMs === void 0 ? {} : { teardownConfirmMs },
 			...resume === void 0 ? {} : { resume },
 			...requestedRetainedAtSettlement === void 0 ? {} : { retainedAtSettlement: requestedRetainedAtSettlement },
-			...ownerWorkspaceRetention === void 0 ? {} : { ownerWorkspaceRetention },
 			...interactiveBindingDir === void 0 ? {} : { interactiveBindingDir }
 		}
 	}, "supervisor.run");
@@ -17108,7 +16368,6 @@ function admitSupervisorRun(task, opts) {
 		slots,
 		controller,
 		persistence,
-		ownerWorkspaceRetention,
 		deadlineCheckIn,
 		budgetStopHoldMs
 	};
@@ -17126,10 +16385,11 @@ async function joinRunChildren(join, settleGraceMs) {
 	await releaseHeldEnvironments(scope);
 	join.teardownUnconfirmed = unconfirmedTeardowns(scope);
 	await settleManagerWork(scope);
+	join.teardownUnconfirmed = unconfirmedTeardowns(scope);
 	if (!persistence.failed && join.retainedAtSettlement === "release") join.teardownUnconfirmed = await releaseRetainedEnvironments(scope);
 	const releasing = !persistence.failed && join.retainedAtSettlement === "release";
 	await confirmRetriableTeardowns(join, releasing);
-	join.teardownUnconfirmed = [...join.teardownUnconfirmed, ...unrecoveredRetainedChildren(scope, join.resumeFrom)];
+	join.teardownUnconfirmed = await unrecoveredRetainedChildren(join);
 	for (const node of join.teardownUnconfirmed) await join.opts.journal.appendEvent(join.opts.runId, {
 		kind: "teardown-unconfirmed",
 		...unconfirmedRecord(node),
@@ -17138,36 +16398,9 @@ async function joinRunChildren(join, settleGraceMs) {
 	});
 	if (releasing) await closeRetainedSlots(scope);
 }
-/**
-* A first teardown that failed or answered late is not the provider's last word, and a run that
-* settles over it leaves the sandbox running: cancelling 20 Discovery lanes
-* left 2 workers running. Ask again until confirmed or out of time.
-*/
-async function confirmRetriableTeardowns(join, releasing) {
-	const { opts, scope } = join;
-	const confirmWindowMs = opts.teardownConfirmMs ?? 3e5;
-	if (!(join.teardownUnconfirmed.length > 0 && confirmWindowMs > 0 && hasRetriableTeardowns(scope, releasing))) return;
-	const pending = join.teardownUnconfirmed;
-	for (const node of pending) await opts.journal.appendEvent(opts.runId, {
-		kind: "teardown-pending",
-		...unconfirmedRecord(node),
-		seq: join.teardownSeq++,
-		at: new Date(join.now()).toISOString()
-	});
-	join.teardownUnconfirmed = await confirmSettledTeardowns(scope, confirmWindowMs, releasing);
-	const still = new Set(join.teardownUnconfirmed.map((node) => node.id));
-	for (const node of pending) {
-		if (still.has(node.id)) continue;
-		await opts.journal.appendEvent(opts.runId, {
-			kind: "teardown-confirmed",
-			id: node.id,
-			seq: join.teardownSeq++,
-			at: new Date(join.now()).toISOString()
-		});
-	}
-}
-/** Retained children a resume restored from the journal but never adopted into the live scope. */
-function unrecoveredRetainedChildren(scope, resumeFrom) {
+/** Retained custody absent from the live scope, including a cold cancellation without ports. */
+async function unrecoveredRetainedChildren(join) {
+	const { scope, resumeFrom } = join;
 	const adopted = new Set(scope.view.nodes.map((node) => node.id));
 	const unrecovered = [];
 	for (const recovery of resumeFrom?.recoveries ?? []) {
@@ -17193,7 +16426,107 @@ function unrecoveredRetainedChildren(scope, resumeFrom) {
 			detail: "Retained child was not recovered before settlement; source evidence and teardown remain unverified."
 		});
 	}
-	return unrecovered;
+	const unconfirmed = new Map([...join.teardownUnconfirmed, ...unrecovered].map((node) => [node.id, node]));
+	if (resumeFrom === void 0 || !(join.opts.signal?.reason instanceof RunCancellationReason)) return [...unconfirmed.values()];
+	const forest = await loadSpawnForest(join.opts.journal, join.opts.runId);
+	const nestedOwners = new Set(forest.nodes.filter((node) => node.ownedTreeRoot !== void 0).map((node) => node.id));
+	const destroyed = /* @__PURE__ */ new Map();
+	const confirmed = /* @__PURE__ */ new Map();
+	const refs = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const keyOf = (provider, environmentId) => JSON.stringify([provider, environmentId]);
+	const later = (proof, admission) => proof.tree === admission.tree ? proof.index > admission.index : Number.isFinite(proof.at) && Number.isFinite(admission.at) && proof.at > admission.at;
+	for (const [index, { treeRoot, event }] of forest.events.entries()) {
+		const position = {
+			tree: treeRoot,
+			index,
+			at: Date.parse(event.at)
+		};
+		const invocation = JSON.stringify([treeRoot, event.id]);
+		if (event.kind === "environment-teardown" && event.destroyed) {
+			const key = keyOf(event.provider, event.environmentId);
+			destroyed.set(key, [...destroyed.get(key) ?? [], position]);
+		}
+		if (event.kind === "teardown-confirmed") confirmed.set(event.id, [...confirmed.get(event.id) ?? [], position]);
+		if (event.kind === "execution-input" || event.kind === "execution-result" || event.kind === "execution-abandoned") pending.delete(invocation);
+		if (event.kind !== "execution-admitted") continue;
+		const admission = event.admission;
+		const environment = admission.phase === "environment" ? admission : admission.phase === "dispatched" ? admission.controlRef : void 0;
+		if (environment === void 0) {
+			pending.set(invocation, {
+				id: event.id,
+				position
+			});
+			continue;
+		}
+		pending.delete(invocation);
+		const held = refs.get(event.id) ?? /* @__PURE__ */ new Map();
+		const key = keyOf(environment.provider, environment.environmentId);
+		const custody = held.get(key) ?? {
+			ref: {
+				provider: environment.provider,
+				environmentId: environment.environmentId,
+				keptFor: "evidence"
+			},
+			admissions: /* @__PURE__ */ new Map()
+		};
+		custody.admissions.set(treeRoot, position);
+		held.set(key, custody);
+		refs.set(event.id, held);
+	}
+	const discharged = (id, key, custody) => [...custody.admissions.values()].every((admission) => [...destroyed.get(key) ?? [], ...nestedOwners.has(id) ? [] : confirmed.get(id) ?? []].some((proof) => later(proof, admission)));
+	const unknown = new Set([...pending.values()].filter(({ id, position }) => !(confirmed.get(id) ?? []).some((proof) => later(proof, position))).map(({ id }) => id));
+	for (const [id, node] of unconfirmed) {
+		if (node.attempts !== 0 || node.environments?.length || !node.kept?.length || unknown.has(id)) continue;
+		if (node.kept.every((ref) => {
+			const key = keyOf(ref.provider, ref.environmentId);
+			const custody = refs.get(id)?.get(key);
+			return custody !== void 0 && discharged(id, key, custody);
+		})) unconfirmed.delete(id);
+	}
+	for (const node of forest.nodes) {
+		const kept = [...refs.get(node.id) ?? []].filter(([key, custody]) => !discharged(node.id, key, custody)).map(([, custody]) => custody.ref);
+		if (kept.length === 0 && !unknown.has(node.id)) continue;
+		const prior = unconfirmed.get(node.id);
+		const covered = new Set([...prior?.kept ?? [], ...prior?.environments ?? []].map((ref) => keyOf(ref.provider, ref.environmentId)));
+		const missing = kept.filter((ref) => !covered.has(keyOf(ref.provider, ref.environmentId)));
+		if (prior !== void 0 && missing.length === 0) continue;
+		unconfirmed.set(node.id, {
+			...prior ?? {
+				id: node.id,
+				label: node.label,
+				runtime: node.runtime,
+				status: node.status,
+				attempts: 0
+			},
+			...(prior?.kept?.length ?? 0) + missing.length > 0 ? { kept: [...prior?.kept ?? [], ...missing] } : {},
+			detail: prior?.detail ?? "Prior admitted execution has no confirmed teardown; source custody remains unverified."
+		});
+	}
+	return [...unconfirmed.values()];
+}
+/**
+* A first teardown that failed or answered late is not the provider's last word, and a run that
+* settles over it leaves the sandbox running: cancelling 20 Discovery lanes
+* left 2 workers running. Ask again until confirmed or out of time.
+*/
+async function confirmRetriableTeardowns(join, releasing) {
+	const { opts, scope } = join;
+	const confirmWindowMs = opts.teardownConfirmMs ?? 3e5;
+	if (!(join.teardownUnconfirmed.length > 0 && confirmWindowMs > 0 && hasRetriableTeardowns(scope, releasing))) return;
+	const pending = join.teardownUnconfirmed;
+	for (const node of pending) await opts.journal.appendEvent(opts.runId, {
+		kind: "teardown-pending",
+		...unconfirmedRecord(node),
+		seq: join.teardownSeq++,
+		at: new Date(join.now()).toISOString()
+	});
+	join.teardownUnconfirmed = await confirmSettledTeardowns(scope, confirmWindowMs, releasing);
+	const still = new Set(join.teardownUnconfirmed.map((node) => node.id));
+	for (const node of pending) {
+		if (still.has(node.id)) continue;
+		await appendTeardownConfirmation(opts.journal, opts.runId, node.id, new Date(join.now()).toISOString());
+	}
 }
 // src/runtime/supervise/supervisor-run-tree.ts
 async function openRunTree(opts, now) {
@@ -17294,6 +16627,8 @@ function createSupervisor() {
 			const journal = wrapJournalForBreaker(opts.journal, breaker);
 			const scope = createRootScope(intake, opened, journal, now);
 			const openScope = scope;
+			const ownerControl = runtimeOwnedScopeOwnerControl(root);
+			if (ownerControl !== void 0) bindScopeRetainedOwnerProvider(openScope, ownerControl.provider);
 			if (rootLease) rootLease.bind({
 				scope: openScope,
 				cascadeAbort: (reason) => cascade.abort(new RunCancellationReason("root-handle", reason ?? "root handle aborted")),
@@ -17375,7 +16710,7 @@ function createRootScope(intake, opened, journal, now) {
 		journal,
 		blobs: opts.blobs,
 		executors: opts.executors,
-		seams: { [retainedOwnerWorkspaceRetentionSeamKey]: intake.ownerWorkspaceRetention === true },
+		seams: {},
 		depth: 0,
 		maxDepth: opts.maxDepth ?? 16,
 		workerSlots: intake.slots,
@@ -17449,11 +16784,15 @@ async function executeRoot(root) {
 	let executionAborted = controller.signal.aborted;
 	let allChildrenDownAtSettle = false;
 	let parked = false;
+	let rootStarted = false;
 	try {
 		await startScopeRecoveries(scope);
 		actOutcome = {
 			ok: true,
-			out: await runAbortable(root.run, controller.signal, "supervisor aborted")
+			out: await runAbortable(() => {
+				rootStarted = true;
+				return root.run();
+			}, controller.signal, "supervisor aborted")
 		};
 	} catch (error) {
 		if (error instanceof RunParkedError && error.runId === opts.runId) {
@@ -17480,7 +16819,7 @@ async function executeRoot(root) {
 					error
 				};
 			}
-			if (!persistence.failed) try {
+			if (rootStarted && !persistence.failed) try {
 				await finalizeScopeOwnerMaterialization(scope);
 			} catch (error) {
 				if (actOutcome?.ok !== false) actOutcome = {
@@ -17585,4 +16924,4 @@ async function noWinner(settled, rejection) {
 }
 export { DEFAULT_PEER_MAIL_LIMITS as $, promptModelProfileMaterialization as $t, createSandboxForSpec as A, bridgeModelRouteRefusal as At, createRouterTranscript as B, defaultRunCommand as Bt, createExecutor as C, admitContinuationPolicy as Ct, runAgentRounds as D, failedItems as Dt, createSteerableSandboxSession as E, createContinuationKeeper as Et, codeModeArguments as F, harnessUsageIsEmpty as Ft, LEAF_CONTINUATION_TASK as G, terminateProcessTreeAndConfirm as Gt, createAgentEnvironmentProviderRegistry as H, runWorktreeHarness as Ht, codeModeModelOutput as I, readCodexRolloutSession as It, createInPlaceCliExecutor as J, controlProfileMaterialization as Jt, providerAsSandboxClient as K, assertProfileMaterialization as Kt, createCodeModeTools as L, createPushTraceSource as Lt, acquireSandbox as M, ROUTER_PRICE_SOURCE as Mt, TERMINAL_DECISIONS as N, addHarnessUsage as Nt, assertBoxlessPromptOptions as O, isFiniteNumber as Ot, defaultSelectWinner as P, createCodexRolloutStoreReader as Pt, AUTHORITY_MARKERS as Q, promptControlProfileMaterialization as Qt, runCodeMode as R, bridgeRuntimeAttachmentsKey as Rt, captureReusableExecutorConfig as S, CONTINUATIONS_DIR as St, DEFAULT_SANDBOX_STEERING_MAX_TURNS as T, checkVerdictOf as Tt, resolveAgentEnvironmentProvider as U, LOCAL_HARNESSES as Ut, routerBrain as V, runSettledCommand as Vt, providerAsExecutor as W, harnessInvocation as Wt, createInbox as X, fullProfileMaterialization as Xt, INBOX_RECEIPT_KEY as Y, defineProfileMaterializationContract as Yt, failPendingAfter as Z, profileMaterializationAxes$1 as Zt, withDriverExecutor as _, CheckUnavailableError as _t, assertRunParking as a, projectSandboxOutcome as an, peerMailVerbNames as at, createExecutorRegistry as b, mapExecutorResult as bt, sleepScopeWait as c, HarnessTurnFailedError as ct, runFinalizer as d, isContentFilterRefusal as dt, renderUnsupported as en, PEER_MAIL_WIRE_KEY as et, runTree as f, summarizeDriverAttempts as ft, isDriverSpec as g, preflightPublicCoordination as gt, driverExecutorFactory as h, upstreamUnavailableSignal as ht, RunParkedError as i, worktreeCliProfileMaterialization as in, peerMailTools as it, createSandboxLineage as j, priceTokens as jt, readPromptOptions as k, bridgeAdmissionRefusal as kt, withRunParking as l, abandonablePending as lt, driverChild as m, undispatchedCredentialExit as mt, createSupervisor as n, sandboxProfileMaterialization as nn, createPeerMailbox as nt, bindScopeParkingDrain as o, readSandboxOutcome as on, taskToPrompt$1 as ot, createRootHandle as p, transientFailureKind as pt, createWorktreeCliExecutor as q, assertProfileMaterializes as qt, assertResumeLimits as r, unsupportedProfileDimensions as rn, isPeerMailEnvelope as rt, readRunParking as s, DriverAttemptsExhaustedError as st, DEFAULT_MAX_DEPTH as t, sandboxActProfileMaterialization as tn, claimsAuthority as tt, bestDelivered as u, classifyDriverFailure as ut, InMemoryResultBlobStore as v, gateFactoryOnDeliverable as vt, snapshotExecutorConfig as w, bestComposite as wt, bindReusableExecutorExecutionId as x, verdictFromJudgeScore as xt, InMemorySpawnJournal as y, gateOnDeliverable as yt, toolResultText as z, bridgeStopSignalKey as zt };
 
-//# sourceMappingURL=supervisor-CwANBb9-.js.map
+//# sourceMappingURL=supervisor-B6sl14OR.js.map