@tangle-network/agent-runtime 0.175.0 → 0.177.1

package/dist/{supervisor-Bt1XLCVq.js → supervisor-ChLgoYhG.js}

@@ -1,20 +1,21 @@
-import { C as runtimeOwnedScopeOwnerRuntime, S as runtimeOwnedPendingExecutorMaterialization, T as unknownMaterializationReceipt, _ as runtimeOwnedDeferredExecutorRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorMaterialization, c as knownExecutionBindingReceipt, g as recordRuntimeOwnedProviderModel, h as recordRuntimeOwnedProviderIdentityConflict, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderDispatchNotStarted, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderAttemptStart, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, w as unknownExecutionBindingReceipt, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding } from "./materialization-Ct3I4wu3.js";
-import { f as RuntimeRunStateError, m as ValidationError, r as BackendTransportError } from "./errors-CDZ8XsVj.js";
+import { A as assertEventBinding, B as exactContinuedControlRef, C as runtimeOwnedScopeOwnerRuntime, D as abortError, E as RetainedRunProviderContractError, F as assertWaitDuration, G as freezeControlRef, H as exactSession, I as awaitAbortable$1, J as sameControlCoordinates, K as hasDurableCancel, L as cancellationRequest, M as assertResultBinding, N as assertSequence, O as assertBoundaryBinding, P as assertStableText, R as copyControlRef, S as runtimeOwnedPendingExecutorMaterialization, T as unknownMaterializationReceipt, U as exactSessionCancel, V as exactControlRef, W as exactSessionResult, Y as freshTurnInput, _ as runtimeOwnedDeferredExecutorRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorMaterialization, c as knownExecutionBindingReceipt, g as recordRuntimeOwnedProviderModel, h as recordRuntimeOwnedProviderIdentityConflict, j as assertInteractionBinding, k as assertCanonicalEventBinding, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderDispatchNotStarted, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderAttemptStart, q as isTerminalSessionStatus, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, w as unknownExecutionBindingReceipt, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding, z as delay } from "./materialization-CekWK6OO.js";
+import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, l as RetainedInteractiveBindingError, m as ValidationError, r as BackendTransportError, u as RetainedRunAdmissionError } from "./errors-CDZ8XsVj.js";
 import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal-Tgvp5VS5.js";
+import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, n as FileSpawnJournal, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal--N8Ten1q.js";
 import { _ as unmeteredSpend, a as cloneTokenUsage, b as zeroTokenUsage, d as randomSuffix, f as randomUuid, g as throwIfAborted, h as throwAbort, l as mapWithConcurrency, m as stringifySafe, n as addTokenUsage, o as deleteBoxSafe, p as sleep, r as chargedTokens, s as hasCompleteCacheBreakdown, t as addSpend, u as promptCacheTokenClasses, v as withTimeout, y as zeroSpend } from "./util-D6ZEuBMi.js";
-import { c as notifySandboxEventObserver, i as extractLlmCallEvent, l as sandboxEventServedBackend, r as createSandboxToolPartState, s as mapSandboxToolEvent, t as assertSandboxServedModel, u as sandboxProgressEvents } from "./sandbox-events-BVjstFgb.js";
+import { c as notifySandboxEventObserver, i as extractLlmCallEvent, l as sandboxEventServedBackend, m as parseCanonicalTransportEvent, p as extractTransportEventIdentity, r as createSandboxToolPartState, s as mapSandboxToolEvent, t as assertSandboxServedModel, u as sandboxProgressEvents } from "./sandbox-events-BVjstFgb.js";
 import { n as executableAgentSpecSnapshot, r as projectSandboxOutcome, t as executableAgentProfileSnapshot } from "./executable-spec-CkGvdPds.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-Sw4ywhtL.js";
-import { c as linkAbort, i as resolveAgentEnvironmentProvider, l as runAbortable, n as providerAsExecutor, r as providerAsSandboxClient, s as abortError } from "./environment-provider-Bn3652YU.js";
+import { c as linkAbort, i as resolveAgentEnvironmentProvider, l as runAbortable, n as providerAsExecutor, r as providerAsSandboxClient, s as abortError$1 } from "./environment-provider-DKyMWQJd.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
-import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentTurnInputSchema, REASONING_EFFORTS, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, harnessTypeSchema, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
+import { n as assertNoSymlinkDescendant, r as publishExclusiveDurableFile } from "./durable-file-g3YdfEh4.js";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, REASONING_EFFORTS, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, exactAgentInteractiveSessionStart, harnessTypeSchema, nativeContextContinuationTurnDigest, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
 import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
 import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, realpath, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
-import { appendFileSync, constants, createReadStream } from "node:fs";
+import { appendFileSync, constants, createReadStream, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
@@ -10821,6 +10822,1531 @@ function queueOf(units, budget) {
 	};
 }
 //#endregion
+//#region src/runtime/retained-interactive-handle.ts
+function createRetainedInteractiveRunHandle(environment, inputRef, capabilities, requestedStart) {
+	const ref = freezeInteractiveRef(inputRef);
+	const source = environment.interactive(ref);
+	if (!sameInteractiveRef(source.ref, ref)) throw new Error("provider reconstructed a different interactive process");
+	if (!source.sendPrompt) throw new Error("provider declared interactive prompt support but exposed no prompt method");
+	return Object.freeze({
+		ref,
+		capabilities,
+		claimControl: async (request, options) => exactClaim(ref, request, await awaitAbortable$1(Promise.resolve().then(() => source.claimControl(request, options)), options?.signal)),
+		status: async (options) => exactStatus(ref, await awaitAbortable$1(Promise.resolve().then(() => source.status(options)), options?.signal), requestedStart),
+		attach: async (request, options) => exactTerminal(ref, request, await awaitAbortable$1(Promise.resolve().then(() => source.attach(request, options)), options?.signal)),
+		sendPrompt: async (command, options) => exactPrompt(ref, await awaitAbortable$1(Promise.resolve().then(() => source.sendPrompt(command, options)), options?.signal), command),
+		stop: async (command, options) => exactStop(ref, await awaitAbortable$1(Promise.resolve().then(() => source.stop(command, options)), options?.signal), command)
+	});
+}
+function freezeInteractiveRef(value) {
+	return detachedSnapshot(AgentInteractiveSessionRefSchema.parse(value), "interactive session ref");
+}
+function exactClaim(ref, request, value) {
+	const acknowledgement = parseProviderAcknowledgement(AgentInteractiveSessionControlClaimAcknowledgementSchema, value, "control claim");
+	if (!agentInteractiveSessionControlClaimAcknowledgementMatchesRequest(request, acknowledgement)) throw new RetainedRunProviderContractError("provider returned a control claim acknowledgement for another request");
+	if (acknowledgement.control && !agentInteractiveSessionControlClaimMatchesRef(ref, acknowledgement.control)) throw new RetainedRunProviderContractError("provider returned a control claim for another interactive process");
+	return acknowledgement;
+}
+function exactPrompt(ref, value, command) {
+	const acknowledgement = parseProviderAcknowledgement(AgentInteractiveSessionPromptAcknowledgementSchema, value, "prompt");
+	if (!agentInteractiveSessionPromptAcknowledgementMatchesCommand(command, acknowledgement)) throw new RetainedRunProviderContractError("provider returned a prompt acknowledgement for another request");
+	if (!agentInteractiveSessionControlClaimMatchesRef(ref, acknowledgement.control)) throw new RetainedRunProviderContractError("provider returned a prompt acknowledgement for another interactive process");
+	return acknowledgement;
+}
+function exactStop(ref, value, command) {
+	const acknowledgement = parseProviderAcknowledgement(AgentInteractiveSessionStopAcknowledgementSchema, value, "stop");
+	if (!agentInteractiveSessionStopAcknowledgementMatchesCommand(command, acknowledgement)) throw new RetainedRunProviderContractError("provider returned a stop acknowledgement for another request");
+	if (!agentInteractiveSessionControlClaimMatchesRef(ref, acknowledgement.control)) throw new RetainedRunProviderContractError("provider returned a stop acknowledgement for another interactive process");
+	return acknowledgement;
+}
+function parseProviderAcknowledgement(schema, value, operation) {
+	try {
+		return schema.parse(value);
+	} catch {
+		throw new RetainedRunProviderContractError(`provider returned an invalid interactive ${operation} acknowledgement`);
+	}
+}
+function exactStatus(ref, value, requestedStart) {
+	let status;
+	try {
+		status = AgentInteractiveSessionStatusSchema.parse(value);
+	} catch (error) {
+		if (requestedStart === void 0) throw error;
+		throw new RetainedInteractiveBindingError(detachedSnapshot(requestedStart, "interactive status binding request"), {}, { cause: error });
+	}
+	if (!agentInteractiveSessionStatusMatchesRef(ref, status)) {
+		if (requestedStart !== void 0) throw new RetainedInteractiveBindingError(detachedSnapshot(requestedStart, "interactive status binding request"), detachedSnapshot({ status: detachedSnapshot(status, "interactive provider status") }, "interactive provider status result"), { cause: /* @__PURE__ */ new Error("provider returned status for another interactive process") });
+		throw new Error("provider returned status for another interactive process");
+	}
+	return status;
+}
+function exactTerminal(ref, request, terminal) {
+	const terminalRef = TerminalSessionRefSchema.parse(terminal.ref);
+	TerminalReplayWindowSchema.parse(terminal.cursors);
+	if (terminalRef.parentExecutionId !== ref.run.executionId) throw new Error("provider attached a terminal from another interactive run");
+	AgentInteractiveSessionControlClaimSchema.parse(terminal.control);
+	if (!agentInteractiveSessionControlClaimMatchesRef(ref, terminal.control)) throw new Error("provider attached a terminal with a claim for another interactive process");
+	if (canonicalCandidateDigest(terminal.control) !== canonicalCandidateDigest(request.control)) throw new Error("provider attached a terminal with a different interactive control claim");
+	return terminal;
+}
+function sameInteractiveRef(left, right) {
+	return canonicalCandidateDigest(left) === canonicalCandidateDigest(right);
+}
+//#endregion
+//#region src/runtime/retained-interactive-lifecycle.ts
+const INTERACTIVE_CLEANUP_TIMEOUT_MS = 3e4;
+/** Create one environment while retaining ownership if cancellation wins the race. */
+async function createInteractiveEnvironment(create, signal) {
+	if (signal?.aborted) throw abortError(signal.reason);
+	const creation = Promise.resolve().then(create);
+	if (signal === void 0) return creation;
+	return new Promise((resolve, reject) => {
+		let owner = "pending";
+		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			disposeInteractiveEnvironment(creation, signal.reason);
+			reject(abortError(signal.reason));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		creation.then((environment) => {
+			if (owner !== "pending") return;
+			owner = "caller";
+			removeAbortListener();
+			resolve(environment);
+		}, (error) => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			reject(error);
+		});
+	});
+}
+/** Start one process while destroying its unreturned environment on cancellation. */
+async function startInteractiveProcess(environment, start, signal) {
+	if (signal?.aborted) {
+		disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
+		throw abortError(signal.reason);
+	}
+	const pending = Promise.resolve().then(start);
+	if (signal === void 0) return pending;
+	return new Promise((resolve, reject) => {
+		let owner = "pending";
+		const removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			disposeInteractiveEnvironment(Promise.resolve(environment), signal.reason);
+			reject(abortError(signal.reason));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		pending.then((result) => {
+			if (owner !== "pending") return;
+			owner = "caller";
+			removeAbortListener();
+			resolve(result);
+		}, (error) => {
+			if (owner !== "pending") return;
+			owner = "runtime";
+			removeAbortListener();
+			reject(error);
+		});
+	});
+}
+/** Destroy an environment with fresh, bounded cleanup authority. */
+async function destroyInteractiveEnvironment(environment) {
+	if (!environment.destroy) throw new Error(`provider environment "${environment.id}" does not expose destroy()`);
+	const controller = new AbortController();
+	const timeout = /* @__PURE__ */ new Error("interactive environment cleanup timed out");
+	let timer;
+	const destruction = Promise.resolve().then(() => environment.destroy?.({ signal: controller.signal }));
+	destruction.catch(() => void 0);
+	try {
+		await Promise.race([destruction, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				controller.abort(timeout);
+				reject(timeout);
+			}, INTERACTIVE_CLEANUP_TIMEOUT_MS);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+function disposeInteractiveEnvironment(environment, abortReason) {
+	environment.then(destroyInteractiveEnvironment, () => void 0).catch((cleanupError) => {
+		const reason = abortReason instanceof Error ? abortReason : new Error(String(abortReason));
+		const failure = new AggregateError([reason, cleanupError], "cancelled interactive environment cleanup failed");
+		process.emitWarning(failure, { code: "AGENT_RUNTIME_INTERACTIVE_CLEANUP_FAILED" });
+	});
+}
+//#endregion
+//#region src/runtime/retained-run-intent.ts
+/**
+* Project environment creation input into public digest material.
+*
+* Opaque values never enter the material or its digest. Public scalar fields
+* remain bound directly, while opaque records retain only their key names.
+* Secret names remain public binding data, so changing requested credentials
+* still conflicts before provider effects begin.
+*/
+function retainedCreateMaterial(environment) {
+	return {
+		...environment.backend === void 0 ? {} : { backend: environment.backend },
+		...environment.workspace === void 0 ? {} : { workspaceDigest: canonicalCandidateDigest(publicWorkspaceMaterial(environment.workspace)) },
+		...environment.resources === void 0 ? {} : { resourcesDigest: canonicalCandidateDigest(publicResourceMaterial(environment.resources)) },
+		...environment.name === void 0 ? {} : { name: environment.name },
+		...environment.env === void 0 ? {} : { environmentVariableNames: retainedObjectNames(environment.env) },
+		...environment.secrets === void 0 ? {} : { secretNames: retainedSecretNames(environment.secrets) },
+		...environment.metadata === void 0 ? {} : { metadataKeys: retainedObjectNames(environment.metadata) },
+		...environment.providerOptions === void 0 ? {} : { providerOptionNames: retainedObjectNames(environment.providerOptions) }
+	};
+}
+/** Add the retained ownership marker without attaching turn identity. */
+function retainedEnvironmentMetadata(metadata, idempotencyKey) {
+	return {
+		...metadata,
+		retainedIdempotencyKey: idempotencyKey
+	};
+}
+function publicWorkspaceMaterial(workspace) {
+	return {
+		...workspace.environment === void 0 ? {} : { environment: workspace.environment },
+		...workspace.image === void 0 ? {} : { image: workspace.image },
+		...workspace.repoUrl === void 0 ? {} : { repoUrl: workspace.repoUrl },
+		...workspace.gitRef === void 0 ? {} : { gitRef: workspace.gitRef },
+		...workspace.cwd === void 0 ? {} : { cwd: workspace.cwd },
+		...workspace.providerOptions === void 0 ? {} : { providerOptionNames: retainedObjectNames(workspace.providerOptions) }
+	};
+}
+function publicResourceMaterial(resources) {
+	return {
+		...resources.cpu === void 0 ? {} : { cpu: resources.cpu },
+		...resources.memoryMb === void 0 ? {} : { memoryMb: resources.memoryMb },
+		...resources.diskMb === void 0 ? {} : { diskMb: resources.diskMb },
+		...resources.gpu === void 0 ? {} : { gpu: resources.gpu },
+		...resources.providerOptions === void 0 ? {} : { providerOptionNames: retainedObjectNames(resources.providerOptions) }
+	};
+}
+function retainedObjectNames(value) {
+	return Object.keys(value).sort();
+}
+function retainedSecretNames(secrets) {
+	return Array.isArray(secrets) ? [...secrets].sort() : Object.keys(secrets).sort();
+}
+/** Project one headless turn into the material that `freshTurnInput` forwards. */
+function retainedTurnMaterial(input) {
+	return {
+		...input.prompt === void 0 ? {} : { prompt: input.prompt },
+		...input.parts === void 0 ? {} : { parts: input.parts },
+		...input.model === void 0 ? {} : { model: input.model },
+		...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+		...input.context === void 0 ? {} : { context: input.context },
+		...input.interactions === void 0 ? {} : { interactions: input.interactions },
+		...input.providerOptions === void 0 ? {} : { providerOptions: input.providerOptions }
+	};
+}
+//#endregion
+//#region src/runtime/interaction-capabilities.ts
+/**
+* Check one turn's interaction request before the provider can dispatch it.
+*
+* A requested interaction is durable only when the provider can replay its
+* event and safely replay the response command. An unsupported request fails
+* before environment creation or dispatch begins.
+*/
+function assertRequestedInteractionCapabilities(providerName, requested, capabilities) {
+	const requestedKinds = Object.entries(requested ?? {}).filter(([, enabled]) => enabled === true).map(([kind]) => kind);
+	if (requestedKinds.length === 0) return;
+	const interactions = capabilities.interactions;
+	if (!interactions) throw new Error(`provider "${providerName}" does not support requested interactions: ${requestedKinds.join(", ")}`);
+	const unsupportedKinds = requestedKinds.filter((kind) => !interactions.kinds.includes(kind));
+	if (unsupportedKinds.length > 0) throw new Error(`provider "${providerName}" does not support requested interaction kinds: ${unsupportedKinds.join(", ")}`);
+	if (interactions.replay !== true || interactions.responseIdempotency !== true) throw new Error(`provider "${providerName}" cannot safely dispatch requested interactions without replay and response idempotency`);
+}
+//#endregion
+//#region src/runtime/retained-run-events.ts
+async function* retainedRunEvents(session, controlRef, options, now) {
+	const after = options?.after;
+	if (after) {
+		assertStableText(after.cursor, "replay cursor");
+		assertSequence(after.sequence, "replay sequence");
+	}
+	let nextSequence = after === void 0 ? 1 : after.sequence + 1;
+	let lastSequence = after?.sequence ?? -1;
+	const seen = /* @__PURE__ */ new Set();
+	let firstAfterEvent = after !== void 0;
+	const iterator = session.events({
+		...after === void 0 ? {} : { since: after.cursor },
+		...controlRef.executionId === void 0 ? {} : { executionId: controlRef.executionId },
+		...options?.signal === void 0 ? {} : { signal: options.signal }
+	})[Symbol.asyncIterator]();
+	try {
+		for (;;) {
+			const next = await awaitAbortable$1(Promise.resolve().then(() => iterator.next()), options?.signal);
+			if (next.done) break;
+			const source = next.value;
+			const identity = extractTransportEventIdentity(source);
+			const sourceCursor = identity.cursor ?? identity.eventId;
+			assertEventBinding(source, controlRef);
+			if (sourceCursor === after?.cursor) continue;
+			const event = canonicalEvent(source);
+			if (!event) continue;
+			assertCanonicalEventBinding(controlRef, event);
+			if (firstAfterEvent && after !== void 0) {
+				if (identity.sequence !== void 0 && identity.sequence <= after.sequence) throw new Error("provider replay did not prove that the first event follows the requested cursor");
+				firstAfterEvent = false;
+			}
+			const eventId = identity.eventId ?? identity.cursor;
+			if (!eventId) throw new Error("replayable canonical event has no stable provider event id or cursor");
+			assertStableText(eventId, "provider event id");
+			if (seen.has(eventId)) throw new Error(`provider replay repeated event id "${eventId}"`);
+			seen.add(eventId);
+			const sequence = identity.sequence ?? nextSequence;
+			if (sequence <= lastSequence) throw new Error(`provider event sequence is not monotonic: ${sequence} follows ${lastSequence}`);
+			const occurredAt = identity.occurredAt;
+			yield RuntimeEventEnvelopeSchema.parse({
+				runId: controlRef.runId,
+				eventId,
+				sequence,
+				cursor: identity.cursor ?? eventId,
+				...occurredAt === void 0 ? {} : { occurredAt },
+				receivedAt: new Date(now()).toISOString(),
+				event
+			});
+			lastSequence = sequence;
+			nextSequence = sequence + 1;
+		}
+	} catch (error) {
+		if (options?.signal?.aborted) {
+			try {
+				Promise.resolve(iterator.return?.()).catch(() => void 0);
+			} catch {}
+			throw abortError(options.signal.reason);
+		}
+		if (error instanceof RetainedRunProviderContractError) throw error;
+		throw new RetainedRunProviderContractError(error instanceof Error ? error.message : "provider retained event stream failed", {
+			code: "RETAINED_EVENT_STREAM_INVALID",
+			cause: error
+		});
+	} finally {
+		if (!options?.signal?.aborted) await iterator.return?.();
+	}
+}
+function canonicalEvent(source) {
+	return parseCanonicalTransportEvent(source.type, source.data, source.normalized ?? source.data.normalized, "provider");
+}
+//#endregion
+//#region src/runtime/retained-run-handle.ts
+function createRetainedRunHandle(environment, session, initialControlRef, capabilities, now) {
+	const clock = now ?? Date.now;
+	const measuredCapabilities = structuredClone(capabilities);
+	let activeControlRef = freezeControlRef(initialControlRef);
+	const snapshot = async (reason, signal) => {
+		if (signal?.aborted) throw abortError(signal.reason);
+		let status;
+		try {
+			status = await awaitAbortable$1(Promise.resolve().then(() => session.status({ signal })), signal);
+		} catch {
+			if (signal?.aborted) throw abortError(signal.reason);
+			status = "unknown";
+		}
+		const effect = status === "cancelled" ? "cancelled" : status === "completed" || status === "failed" || status === "expired" ? "not_live" : "unknown";
+		return {
+			runId: activeControlRef.runId,
+			controlRef: copyControlRef(activeControlRef),
+			status,
+			effect,
+			observedAt: new Date(clock()).toISOString(),
+			...reason === void 0 ? {} : { reason },
+			...signal?.aborted ? { signal: String(signal.reason ?? "aborted") } : {}
+		};
+	};
+	return {
+		get controlRef() {
+			return copyControlRef(activeControlRef);
+		},
+		get capabilities() {
+			return structuredClone(measuredCapabilities);
+		},
+		status: async (options) => {
+			const waitMs = options?.waitMs ?? 0;
+			assertWaitDuration(waitMs, "retained status wait");
+			const initial = await snapshot(void 0, options?.signal);
+			if (waitMs === 0 || isTerminalSessionStatus(initial.status)) return initial;
+			const deadline = Date.now() + waitMs;
+			let current = initial;
+			while (Date.now() < deadline) {
+				await delay(Math.min(25, Math.max(1, deadline - Date.now())), options?.signal);
+				current = await snapshot(void 0, options?.signal);
+				if (current.status !== initial.status || isTerminalSessionStatus(current.status)) return current;
+			}
+			return current;
+		},
+		events: (options) => retainedRunEvents(session, copyControlRef(activeControlRef), options, clock),
+		result: async () => {
+			let candidate;
+			try {
+				candidate = await exactSessionResult(session);
+			} catch (error) {
+				if (error instanceof RetainedRunProviderContractError) throw error;
+				throw new RetainedRunProviderContractError(error instanceof Error ? error.message : "provider retained result read failed", {
+					code: "RETAINED_RESULT_READ_FAILED",
+					cause: error
+				});
+			}
+			const parsed = AgentTurnResultSchema.safeParse(candidate);
+			if (!parsed.success) throw new RetainedRunProviderContractError("provider returned an invalid retained result", {
+				code: "RETAINED_RESULT_SCHEMA_INVALID",
+				cause: parsed.error
+			});
+			try {
+				assertResultBinding(activeControlRef, parsed.data);
+			} catch (error) {
+				throw new RetainedRunProviderContractError(error instanceof Error ? error.message : "provider returned an unbound retained result", {
+					code: "RETAINED_RESULT_BINDING_INVALID",
+					cause: error
+				});
+			}
+			return structuredClone(parsed.data);
+		},
+		async respondToInteraction(command, options) {
+			const exactCommand = InteractionResponseCommandSchema.parse(command);
+			assertInteractionBinding(activeControlRef, exactCommand);
+			if (measuredCapabilities.interactions?.replay !== true || measuredCapabilities.interactions.responseIdempotency !== true) throw new Error(`provider "${activeControlRef.provider}" does not promise retry-safe interaction responses`);
+			const respond = session.respondToInteraction ?? environment.respondToInteraction;
+			if (!respond) throw new Error(`provider "${activeControlRef.provider}" does not support interaction responses`);
+			const acknowledgement = InteractionAcknowledgementSchema.parse(await awaitAbortable$1(Promise.resolve().then(() => respond.call(session.respondToInteraction ? session : environment, exactCommand, options)), options?.signal));
+			if (acknowledgement.operationId !== exactCommand.operationId || acknowledgement.commandDigest !== exactCommand.commandDigest || canonicalCandidateDigest(acknowledgement.binding) !== canonicalCandidateDigest(exactCommand.binding)) throw new Error("provider returned an interaction acknowledgement for another command");
+			return structuredClone(acknowledgement);
+		},
+		async contextBoundary(options) {
+			if (!session.contextBoundary) return null;
+			const proof = await awaitAbortable$1(Promise.resolve().then(() => session.contextBoundary(options)), options?.signal);
+			if (proof === null) return null;
+			const exactProof = NativeContextBoundaryProofSchema.parse(proof);
+			assertBoundaryBinding(activeControlRef, exactProof);
+			return structuredClone(exactProof);
+		},
+		async continueNative(request, turn) {
+			const exactRequest = NativeContextContinuationRequestSchema.parse(request);
+			if (!sameControlCoordinates(exactRequest.run, activeControlRef)) throw new Error("native continuation request targets another retained run");
+			const { timeoutMs, signal, ...semanticTurn } = turn;
+			if (nativeContextContinuationTurnDigest(semanticTurn) !== exactRequest.turnDigest) throw new Error("native continuation request targets another user turn");
+			if (measuredCapabilities.nativeContinuation?.atomicBoundary !== true || measuredCapabilities.nativeContinuation.requestIdempotency !== true || !session.continueNative) throw new Error(`provider "${activeControlRef.provider}" does not support retry-safe native continuation`);
+			const outcome = AgentNativeContextContinuationResultSchema.parse(await awaitAbortable$1(Promise.resolve().then(() => session.continueNative(exactRequest, {
+				turn: semanticTurn,
+				...timeoutMs === void 0 ? {} : { timeoutMs },
+				...signal === void 0 ? {} : { signal }
+			})), signal));
+			if (outcome.acknowledgement.operationId !== exactRequest.operationId || outcome.acknowledgement.requestDigest !== exactRequest.requestDigest) throw new Error("provider returned a native continuation result for another request");
+			if (outcome.acknowledgement.actualBoundary !== void 0) {
+				const actualBoundary = NativeContextBoundaryProofSchema.parse(outcome.acknowledgement.actualBoundary);
+				assertBoundaryBinding(exactRequest.run, actualBoundary);
+			}
+			if (outcome.acknowledgement.status !== "accepted" && outcome.acknowledgement.status !== "replayed") return structuredClone(outcome);
+			if (!("result" in outcome) || !("controlRef" in outcome)) throw new Error("provider omitted the successful native continuation result");
+			if (!agentNativeContextContinuationResultMatchesRequest(exactRequest, outcome)) throw new Error("provider returned a native continuation result for another request");
+			const nextControlRef = exactContinuedControlRef(outcome.controlRef, activeControlRef);
+			assertResultBinding(nextControlRef, outcome.result);
+			activeControlRef = freezeControlRef(nextControlRef);
+			return structuredClone({
+				...outcome,
+				controlRef: copyControlRef(activeControlRef)
+			});
+		},
+		async cancel(options) {
+			assertStableText(options.operationId, "retained cancellation operation id");
+			if (options.reason !== void 0) assertStableText(options.reason, "retained cancellation reason");
+			if (options.signal?.aborted) throw abortError(options.signal.reason);
+			if (!hasDurableCancel(session)) throw new Error(`provider "${activeControlRef.provider}" does not expose durable cancellation operations`);
+			const request = cancellationRequest(activeControlRef, options.operationId, options.reason);
+			let effect = "unknown";
+			let providerStatus;
+			try {
+				const acknowledgement = await exactSessionCancel(session, request, { signal: options.signal });
+				effect = acknowledgement.effect;
+				providerStatus = acknowledgement.status;
+			} catch (error) {
+				if (error instanceof RetainedRunProviderContractError) throw error;
+				if (error instanceof Error && error.name === "AbortError") throw error;
+				effect = "unknown";
+			}
+			const current = await snapshot(options.reason, options.signal);
+			const observedEffect = effect === "unknown" && providerStatus === void 0 && current.status === "cancelled" ? "cancelled" : effect;
+			const acknowledgement = {
+				operationId: options.operationId,
+				requestDigest: request.requestDigest,
+				status: providerStatus ?? (observedEffect === "unknown" ? "unknown" : "accepted"),
+				effect: observedEffect,
+				snapshot: {
+					...current,
+					effect: observedEffect
+				},
+				...options.reason === void 0 ? {} : { reason: options.reason },
+				...options.signal?.aborted ? { signal: String(options.signal.reason ?? "aborted") } : {}
+			};
+			return structuredClone(acknowledgement);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/retained-run-start.ts
+/**
+* Mint deterministic dispatch coordinates from the two caller-supplied keys.
+* The same `(idempotencyKey, turnId)` pair yields the same coordinates in
+* every process, so a pre-dispatch admission record always names the exact
+* session and execution the dispatch will request. Format is readable, not
+* hashed, following `deriveExecutionId`: components are URL-encoded so
+* delimiters inside caller keys cannot collapse distinct pairs, and the
+* result stays inside the 256-byte identifier bound.
+*/
+function mintRetainedIdentity(idempotencyKey, turnId) {
+	const base = `${encodeURIComponent(idempotencyKey)}:${encodeURIComponent(turnId)}`;
+	const sessionId = `retained-session:${base}`;
+	const executionId = `retained-execution:${base}`;
+	if (executionId.length > 256) throw new RangeError("minted retained identity must not exceed 256 bytes");
+	return {
+		sessionId,
+		executionId
+	};
+}
+/**
+* Dispatch one detached, replayable run and return only after exact durable
+* coordinates are confirmed by the provider and persisted by the caller.
+*
+* The required `onAdmission` hook first records a digest-only intent before
+* creation, then records recovery coordinates and the verified exact control
+* reference. The returned promise resolves only after the dispatched admission
+* is durable, so a crash cannot lose a successful start's exact reference.
+*
+* @stable
+*/
+async function startRetainedRun(options) {
+	assertStableText(options.environment.idempotencyKey, "environment idempotency key");
+	assertStableText(options.turn.turnId, "turn idempotency key");
+	if (options.identity !== void 0) {
+		assertStableText(options.identity.sessionId, "retained session id");
+		assertStableText(options.identity.executionId, "retained execution id");
+	}
+	if (typeof options.onAdmission !== "function") throw new Error("startRetainedRun requires an awaited onAdmission durability hook");
+	const identity = options.identity ?? mintRetainedIdentity(options.environment.idempotencyKey, options.turn.turnId);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const intent = retainedRunIntent(options, identity);
+	if (options.intent === void 0) await admitDurably(options.onAdmission, intent);
+	else assertExactRetainedRunIntent(options.intent, intent);
+	const providerCapabilities = await assertRetainedCapabilities(options.provider);
+	assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, providerCapabilities);
+	const environment = await options.provider.create({
+		...options.environment,
+		metadata: retainedEnvironmentMetadata(options.environment.metadata, options.environment.idempotencyKey)
+	});
+	let capabilities;
+	try {
+		capabilities = retainedCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
+		assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, capabilities);
+	} catch (error) {
+		try {
+			await environment.destroy?.();
+		} catch (cleanupError) {
+			throw new AggregateError([error, cleanupError], "retained run environment published invalid capabilities and could not be destroyed");
+		}
+		throw error;
+	}
+	if (!environment.dispatch || !environment.session) {
+		try {
+			await environment.destroy?.();
+		} catch (cleanupError) {
+			throw new AggregateError([/* @__PURE__ */ new Error(`provider "${options.provider.name}" does not expose detached session control`), cleanupError], "retained run could not start and its unused environment could not be destroyed");
+		}
+		throw new Error(`provider "${options.provider.name}" does not expose detached session control`);
+	}
+	return dispatchRetainedRun({
+		provider: options.provider,
+		environment,
+		environmentIdempotencyKey: options.environment.idempotencyKey,
+		turn: options.turn,
+		identity,
+		onAdmission: options.onAdmission,
+		capabilities,
+		now: options.now
+	});
+}
+/**
+* Dispatch a fresh retained session inside an existing provider environment.
+*
+* This operation reuses only the environment. It does not append to a prior
+* harness chat and does not claim native conversation continuity. The caller
+* must use `RetainedRunHandle.continueNative` for a verified same-chat turn.
+*
+* @stable
+*/
+async function startRetainedRunInEnvironment(options) {
+	assertStableText(options.environment.id, "retained environment id");
+	assertStableText(options.environment.idempotencyKey, "environment idempotency key");
+	assertStableText(options.turn.turnId, "turn idempotency key");
+	if (options.identity !== void 0) {
+		assertStableText(options.identity.sessionId, "retained session id");
+		assertStableText(options.identity.executionId, "retained execution id");
+	}
+	if (typeof options.onAdmission !== "function") throw new Error("startRetainedRunInEnvironment requires an awaited onAdmission durability hook");
+	const identity = options.identity ?? mintRetainedIdentity(options.environment.idempotencyKey, options.turn.turnId);
+	const providerCapabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.get(options.environment.id);
+	if (!environment) throw new Error(`provider "${options.provider.name}" no longer holds environment "${options.environment.id}"`);
+	if (environment.id !== options.environment.id || environment.provider !== options.provider.name) throw new Error("provider reconstructed a different retained environment");
+	const capabilities = retainedCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
+	assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, capabilities);
+	if (!environment.dispatch || !environment.session) throw new Error(`provider "${options.provider.name}" does not expose detached session control`);
+	await assertRetainedEnvironmentOwnership(options.provider, environment.id, options.environment.idempotencyKey);
+	return dispatchRetainedRun({
+		provider: options.provider,
+		environment,
+		environmentIdempotencyKey: options.environment.idempotencyKey,
+		turn: options.turn,
+		identity,
+		onAdmission: options.onAdmission,
+		capabilities,
+		now: options.now
+	});
+}
+async function assertRetainedEnvironmentOwnership(provider, environmentId, idempotencyKey) {
+	if (!provider.list) throw new Error(`provider "${provider.name}" cannot prove retained environment ownership by metadata`);
+	const matches = (await provider.list({ metadata: { retainedIdempotencyKey: idempotencyKey } })).filter((summary) => summary.id === environmentId && summary.provider === provider.name);
+	if (matches.length !== 1 || matches[0]?.metadata?.retainedIdempotencyKey !== idempotencyKey) throw new Error(`provider "${provider.name}" could not bind environment "${environmentId}" to its retained idempotency key`);
+}
+async function dispatchRetainedRun(options) {
+	const { environment, identity } = options;
+	assertRequestedInteractionCapabilities(options.provider.name, options.turn.interactions, options.capabilities);
+	await admitDurably(options.onAdmission, {
+		phase: "environment",
+		provider: options.provider.name,
+		environmentId: environment.id,
+		idempotencyKey: options.environmentIdempotencyKey,
+		turnId: options.turn.turnId,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId
+	});
+	const destroyIfCreated = async (cause) => {
+		if (environment.creation !== "created") throw cause;
+		try {
+			await environment.destroy?.();
+		} catch (cleanupError) {
+			throw new AggregateError([cause, cleanupError], "retained run dispatch failed and the environment it created could not be destroyed");
+		}
+		throw cause;
+	};
+	let reference;
+	try {
+		reference = await environment.dispatch(freshTurnInput(options.turn, {
+			turnId: options.turn.turnId,
+			detach: true,
+			...identity
+		}));
+	} catch (error) {
+		await destroyIfCreated(error);
+		throw error;
+	}
+	let exact;
+	try {
+		if (reference.provider !== void 0 && reference.provider !== options.provider.name) throw new Error("provider dispatch returned a session reference for another provider");
+		if (reference.id !== identity.sessionId) throw new Error("provider dispatched into another session than the requested identity");
+		const controlRef = exactControlRef(reference.controlRef, {
+			provider: options.provider.name,
+			environmentId: environment.id,
+			sessionId: identity.sessionId
+		});
+		if (controlRef.executionId !== identity.executionId) throw new Error("provider bound another execution than the requested identity");
+		exact = exactSession(environment, controlRef);
+	} catch (error) {
+		const bindingError = new RetainedRunDispatchBindingError({
+			provider: options.provider.name,
+			environmentId: environment.id,
+			sessionId: identity.sessionId,
+			executionId: identity.executionId
+		}, {
+			...reference.id === void 0 ? {} : { id: reference.id },
+			...reference.provider === void 0 ? {} : { provider: reference.provider },
+			...reference.controlRef === void 0 ? {} : { controlRef: reference.controlRef }
+		}, { cause: error });
+		await destroyIfCreated(bindingError);
+		throw bindingError;
+	}
+	await admitDurably(options.onAdmission, {
+		phase: "dispatched",
+		controlRef: freezeControlRef(exact.controlRef),
+		idempotencyKey: options.environmentIdempotencyKey,
+		turnId: options.turn.turnId
+	});
+	return createRetainedRunHandle(environment, exact.session, exact.controlRef, options.capabilities, options.now);
+}
+/**
+* Await one admission record through the caller's durability hook. A rejection
+* keeps the environment alive — the provider state plus any partial admission
+* record is the recovery path — and surfaces as `RetainedRunAdmissionError` so
+* callers can distinguish a persistence failure from a provider failure.
+*/
+async function admitDurably(onAdmission, admission) {
+	const stableAdmission = detachedSnapshot(admission, "retained run admission");
+	try {
+		await onAdmission(stableAdmission);
+	} catch (error) {
+		if (isInteractiveAdmission(stableAdmission)) throw new RetainedInteractiveAdmissionError(stableAdmission, { cause: error });
+		throw new RetainedRunAdmissionError(stableAdmission, { cause: error });
+	}
+}
+function isInteractiveAdmission(admission) {
+	return admission.phase === "interactive_intent" || admission.phase === "interactive_environment" || admission.phase === "interactive_started";
+}
+async function recoverRetainedRun(options) {
+	if ("admission" in options) {
+		if (options.admission.provider !== options.provider.name) throw new Error("retained run intent belongs to another provider");
+		return {
+			outcome: "recovered",
+			handle: await startRetainedRun({
+				provider: options.provider,
+				...options.replay,
+				intent: options.admission,
+				onAdmission: options.onAdmission,
+				now: options.now
+			})
+		};
+	}
+	assertStableText(options.environmentId, "retained environment id");
+	assertStableText(options.sessionId, "retained session id");
+	assertStableText(options.executionId, "retained execution id");
+	const providerCapabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.get(options.environmentId);
+	if (!environment) return { outcome: "not_found" };
+	const capabilities = retainedCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
+	if (!environment.session) return {
+		outcome: "unverifiable",
+		environment
+	};
+	let session;
+	try {
+		session = environment.session(options.sessionId);
+	} catch {
+		return {
+			outcome: "unverifiable",
+			environment
+		};
+	}
+	const parsed = AgentExactRunControlRefSchema.safeParse(session.controlRef);
+	if (!parsed.success) return {
+		outcome: "unverifiable",
+		environment
+	};
+	const controlRef = parsed.data;
+	if (controlRef.provider !== options.provider.name || controlRef.environmentId !== options.environmentId || controlRef.sessionId !== options.sessionId || controlRef.executionId !== options.executionId) throw new Error("provider session is bound to other retained run coordinates");
+	const exact = exactSession(environment, controlRef);
+	return {
+		outcome: "recovered",
+		handle: createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now)
+	};
+}
+function retainedRunIntent(options, identity) {
+	const requestedProfileDigest = canonicalCandidateDigest(options.environment.profile);
+	const requestDigest = canonicalCandidateDigest({
+		kind: "retained-run-intent.v1",
+		provider: options.provider.name,
+		idempotencyKey: options.environment.idempotencyKey,
+		turnId: options.turn.turnId,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId,
+		requestedProfileDigest,
+		create: retainedCreateMaterial(options.environment),
+		turn: retainedTurnMaterial(options.turn)
+	});
+	return {
+		phase: "intent",
+		provider: options.provider.name,
+		idempotencyKey: options.environment.idempotencyKey,
+		turnId: options.turn.turnId,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId,
+		runId: `retained-intent-run:${requestDigest.slice(7)}`,
+		requestedProfileDigest,
+		requestDigest
+	};
+}
+function assertExactRetainedRunIntent(received, expected) {
+	if (canonicalCandidateDigest(parseRetainedRunIntent(received)) !== canonicalCandidateDigest(expected)) throw new Error("retained run intent conflicts with replay material");
+}
+function parseRetainedRunIntent(value) {
+	const stable = detachedSnapshot(value, "retained run intent");
+	if (stable === null || typeof stable !== "object" || Array.isArray(stable)) throw new Error("retained run intent is malformed");
+	const record = stable;
+	const allowed = /* @__PURE__ */ new Set([
+		"phase",
+		"provider",
+		"idempotencyKey",
+		"turnId",
+		"sessionId",
+		"executionId",
+		"runId",
+		"requestedProfileDigest",
+		"requestDigest"
+	]);
+	if (Object.keys(record).some((key) => !allowed.has(key))) throw new Error("retained run intent contains unsupported material");
+	if (record.phase !== "intent") throw new Error("retained run intent has an invalid phase");
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "phase") continue;
+		if (typeof value !== "string" || value.length === 0) throw new Error(`retained run intent field "${key}" is invalid`);
+	}
+	assertDigest$2(record.requestedProfileDigest, "retained run intent profile digest");
+	assertDigest$2(record.requestDigest, "retained run intent request digest");
+	return stable;
+}
+function assertDigest$2(value, label) {
+	if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value)) throw new Error(`${label} is invalid`);
+}
+/** Rebuild a retained-run client without retaining any object from the starter. @stable */
+async function reconnectRetainedRun(options) {
+	const controlRef = AgentExactRunControlRefSchema.parse(options.controlRef);
+	if (controlRef.provider !== options.provider.name) throw new Error(`run provider "${controlRef.provider}" does not match "${options.provider.name}"`);
+	const providerCapabilities = await assertRetainedCapabilities(options.provider);
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const environment = await options.provider.get(controlRef.environmentId);
+	if (!environment) return null;
+	const capabilities = retainedCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
+	const exact = exactSession(environment, controlRef);
+	return createRetainedRunHandle(environment, exact.session, exact.controlRef, capabilities, options.now);
+}
+async function assertRetainedCapabilities(provider) {
+	const capabilities = AgentEnvironmentCapabilitiesSchema.parse(await provider.capabilities());
+	assertRetainedCapabilityRequirements(provider.name, capabilities);
+	return capabilities;
+}
+/**
+* Select the capability document for one concrete environment.
+*
+* A measured environment document is authoritative. An absent document uses
+* the provider document because that provider claims the same guarantee for
+* every environment it creates.
+*/
+function retainedCapabilitiesForEnvironment(providerName, providerCapabilities, environment) {
+	if (environment.capabilities === void 0) return providerCapabilities;
+	const measured = AgentEnvironmentCapabilitiesSchema.parse(environment.capabilities);
+	assertRetainedCapabilityRequirements(providerName, measured);
+	return measured;
+}
+function assertRetainedCapabilityRequirements(providerName, capabilities) {
+	const retained = capabilities.retainedControl;
+	if (retained?.exactRunIdentity !== true || retained.resultIdentity !== true || retained.eventIdentity !== true || retained.cancellationIdempotency !== true || !capabilities.streaming.detach || !capabilities.streaming.replay || !capabilities.streaming.turnIdempotency) throw new Error(`provider "${providerName}" cannot control a retry-safe retained run`);
+}
+//#endregion
+//#region src/runtime/retained-interactive.ts
+/**
+* Start one retry-safe native coding-agent TUI without dispatching a headless turn.
+* The intent admission is durable before provider.create; the environment and
+* process admissions follow only after their exact provider coordinates exist.
+* @stable
+*/
+async function startRetainedInteractiveRun(options) {
+	options.signal?.throwIfAborted();
+	assertStableText(options.environment.idempotencyKey, "environment idempotency key");
+	assertStableText(options.interactiveIdempotencyKey, "interactive idempotency key");
+	if (typeof options.onAdmission !== "function") throw new Error("startRetainedInteractiveRun requires an awaited onAdmission durability hook");
+	if (!options.provider.get) throw new Error(`provider "${options.provider.name}" cannot reconstruct an environment by id`);
+	const profile = agentProfileSchema.parse(options.environment.profile);
+	if (profile.harness === void 0) throw new Error("retained interactive runs require AgentProfile.harness");
+	const requestedProfileDigest = canonicalAgentProfileDigest(profile);
+	const identity = mintRetainedIdentity(options.environment.idempotencyKey, options.interactiveIdempotencyKey);
+	const intent = interactiveIntent(options, profile, identity);
+	if (options.intent === void 0) await admitDurably(options.onAdmission, intent);
+	else assertExactInteractiveIntent(options.intent, intent);
+	const providerCapabilities = AgentEnvironmentCapabilitiesSchema.parse(await awaitAbortable$1(Promise.resolve().then(() => options.provider.capabilities()), options.signal));
+	assertInteractiveCapabilities(options.provider.name, providerCapabilities);
+	const environment = await createInteractiveEnvironment(() => options.provider.create({
+		...options.environment,
+		profile,
+		signal: options.signal,
+		metadata: retainedEnvironmentMetadata(options.environment.metadata, options.environment.idempotencyKey)
+	}), options.signal);
+	let capabilities;
+	try {
+		assertExactEnvironment(options.provider.name, environment);
+		options.signal?.throwIfAborted();
+		capabilities = interactiveCapabilitiesForEnvironment(options.provider.name, providerCapabilities, environment);
+		assertInteractiveMethods(options.provider.name, environment);
+	} catch (error) {
+		await destroyUnusedEnvironment(environment, error);
+		throw error;
+	}
+	const request = interactiveRequest(options, environment, profile, requestedProfileDigest, identity);
+	await admitDurably(options.onAdmission, {
+		phase: "interactive_environment",
+		provider: options.provider.name,
+		environmentId: environment.id,
+		idempotencyKey: options.environment.idempotencyKey,
+		interactiveIdempotencyKey: options.interactiveIdempotencyKey,
+		request
+	});
+	const ref = exactStartedRef(request, await startInteractiveProcess(environment, () => environment.startInteractive(request, { signal: options.signal }), options.signal));
+	await admitDurably(options.onAdmission, {
+		phase: "interactive_started",
+		idempotencyKey: options.environment.idempotencyKey,
+		interactiveIdempotencyKey: options.interactiveIdempotencyKey,
+		ref
+	});
+	return createRetainedInteractiveRunHandle(environment, ref, capabilities, request);
+}
+/** Retry one exact start after its provider response may have been lost. @stable */
+async function recoverRetainedInteractiveRun(options) {
+	options.signal?.throwIfAborted();
+	if (typeof options.onAdmission !== "function") throw new Error("recoverRetainedInteractiveRun requires an awaited onAdmission durability hook");
+	const admission = options.admission;
+	if (admission.provider !== options.provider.name) throw new Error("interactive admission belongs to another provider");
+	if (admission.phase === "interactive_intent") {
+		if (options.replay === void 0) throw new Error("recoverRetainedInteractiveRun requires the original start material for an interactive intent");
+		return startRetainedInteractiveRun({
+			provider: options.provider,
+			...options.replay,
+			intent: admission,
+			onAdmission: options.onAdmission,
+			signal: options.signal
+		});
+	}
+	const request = exactRecoveryRequest(admission);
+	const { environment, capabilities } = await reconstructEnvironment(options.provider, admission.environmentId, options.signal);
+	if (!environment || !capabilities) return null;
+	const ref = exactStartedRef(request, await awaitAbortable$1(Promise.resolve().then(() => environment.startInteractive(request, { signal: options.signal })), options.signal));
+	await admitDurably(options.onAdmission, {
+		phase: "interactive_started",
+		idempotencyKey: admission.idempotencyKey,
+		interactiveIdempotencyKey: admission.interactiveIdempotencyKey,
+		ref
+	});
+	return createRetainedInteractiveRunHandle(environment, ref, capabilities, request);
+}
+function exactRecoveryRequest(admission) {
+	assertStableText(admission.environmentId, "interactive environment id");
+	assertStableText(admission.idempotencyKey, "environment idempotency key");
+	assertStableText(admission.interactiveIdempotencyKey, "interactive idempotency key");
+	const request = exactAgentInteractiveSessionStart(admission.request);
+	const identity = mintRetainedIdentity(admission.idempotencyKey, admission.interactiveIdempotencyKey);
+	if (request.run.provider !== admission.provider || request.run.environmentId !== admission.environmentId || request.run.sessionId !== identity.sessionId || request.run.executionId !== identity.executionId) throw new Error("interactive admission does not match its recovery coordinates");
+	return request;
+}
+/** Rebuild controls for one exact provider-owned coding-agent process. @stable */
+async function reconnectRetainedInteractiveRun(options) {
+	options.signal?.throwIfAborted();
+	const ref = AgentInteractiveSessionRefSchema.parse(options.ref);
+	if (ref.run.provider !== options.provider.name) throw new Error("interactive session reference belongs to another provider");
+	const { environment, capabilities } = await reconstructEnvironment(options.provider, ref.run.environmentId, options.signal);
+	if (!environment || !capabilities) return null;
+	const handle = createRetainedInteractiveRunHandle(environment, ref, capabilities);
+	await handle.status({ signal: options.signal });
+	return handle;
+}
+function interactiveRequest(options, environment, profile, requestedProfileDigest, identity) {
+	const start = {
+		profile,
+		requestedProfileDigest,
+		...options.initialPrompt === void 0 ? {} : { initialPrompt: options.initialPrompt },
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		...options.cols === void 0 ? {} : { cols: options.cols },
+		...options.rows === void 0 ? {} : { rows: options.rows }
+	};
+	return exactAgentInteractiveSessionStart({
+		run: agentInteractiveSessionRunRef({
+			provider: options.provider.name,
+			environmentId: environment.id,
+			...identity
+		}, start),
+		...start
+	});
+}
+function interactiveIntent(options, profile, identity) {
+	const requestedProfileDigest = canonicalAgentProfileDigest(profile);
+	const requestDigest = canonicalCandidateDigest({
+		kind: "retained-interactive-intent.v1",
+		provider: options.provider.name,
+		idempotencyKey: options.environment.idempotencyKey,
+		interactiveIdempotencyKey: options.interactiveIdempotencyKey,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId,
+		requestedProfileDigest,
+		create: retainedCreateMaterial(options.environment),
+		start: sanitizedStartMaterial(options)
+	});
+	return {
+		phase: "interactive_intent",
+		provider: options.provider.name,
+		idempotencyKey: options.environment.idempotencyKey,
+		interactiveIdempotencyKey: options.interactiveIdempotencyKey,
+		sessionId: identity.sessionId,
+		executionId: identity.executionId,
+		runId: `interactive-intent-run:${requestDigest.slice(7)}`,
+		requestedProfileDigest,
+		requestDigest
+	};
+}
+function sanitizedStartMaterial(options) {
+	return {
+		...options.initialPrompt === void 0 ? {} : { initialPrompt: options.initialPrompt },
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		...options.cols === void 0 ? {} : { cols: options.cols },
+		...options.rows === void 0 ? {} : { rows: options.rows }
+	};
+}
+function assertExactInteractiveIntent(received, expected) {
+	if (canonicalCandidateDigest(parseInteractiveIntent(received)) !== canonicalCandidateDigest(expected)) throw new Error("interactive intent conflicts with replay material");
+}
+function parseInteractiveIntent(value) {
+	const stable = detachedSnapshot(value, "interactive intent");
+	if (stable === null || typeof stable !== "object" || Array.isArray(stable)) throw new Error("interactive intent is malformed");
+	const record = stable;
+	const allowed = /* @__PURE__ */ new Set([
+		"phase",
+		"provider",
+		"idempotencyKey",
+		"interactiveIdempotencyKey",
+		"sessionId",
+		"executionId",
+		"runId",
+		"requestedProfileDigest",
+		"requestDigest"
+	]);
+	if (Object.keys(record).some((key) => !allowed.has(key))) throw new Error("interactive intent contains unsupported material");
+	if (record.phase !== "interactive_intent") throw new Error("interactive intent has an invalid phase");
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "phase") continue;
+		if (typeof value !== "string" || value.length === 0) throw new Error(`interactive intent field "${key}" is invalid`);
+	}
+	assertDigest$1(record.requestedProfileDigest, "interactive intent profile digest");
+	assertDigest$1(record.requestDigest, "interactive intent request digest");
+	return stable;
+}
+function assertDigest$1(value, label) {
+	if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value)) throw new Error(`${label} is invalid`);
+}
+async function reconstructEnvironment(provider, environmentId, signal) {
+	if (!provider.get) throw new Error(`provider "${provider.name}" cannot reconstruct an environment by id`);
+	const providerCapabilities = AgentEnvironmentCapabilitiesSchema.parse(await awaitAbortable$1(Promise.resolve().then(() => provider.capabilities()), signal));
+	assertInteractiveCapabilities(provider.name, providerCapabilities);
+	const environment = await awaitAbortable$1(Promise.resolve().then(() => provider.get(environmentId, { signal })), signal);
+	if (!environment) return {
+		environment: null,
+		capabilities: null
+	};
+	assertExactEnvironment(provider.name, environment, environmentId);
+	const capabilities = interactiveCapabilitiesForEnvironment(provider.name, providerCapabilities, environment);
+	assertInteractiveMethods(provider.name, environment);
+	return {
+		environment,
+		capabilities
+	};
+}
+function exactStartedRef(request, value) {
+	const stableRequest = detachedSnapshot(request, "interactive start binding request");
+	let ref;
+	try {
+		ref = AgentInteractiveSessionRefSchema.parse(value);
+	} catch (error) {
+		throw new RetainedInteractiveBindingError(stableRequest, {}, { cause: error });
+	}
+	if (!agentInteractiveSessionRefMatchesStart(request, ref)) throw new RetainedInteractiveBindingError(stableRequest, detachedSnapshot({ ref: detachedSnapshot(ref, "interactive provider start reference") }, "interactive provider start result"), { cause: /* @__PURE__ */ new Error("provider started another interactive run than requested") });
+	return freezeInteractiveRef(ref);
+}
+function assertExactEnvironment(providerName, environment, environmentId) {
+	if (environment.provider !== providerName || environmentId && environment.id !== environmentId) throw new Error("provider returned another interactive environment");
+	assertStableText(environment.id, "interactive environment id");
+}
+function interactiveCapabilitiesForEnvironment(providerName, providerCapabilities, environment) {
+	const capabilities = environment.capabilities === void 0 ? providerCapabilities : AgentEnvironmentCapabilitiesSchema.parse(environment.capabilities);
+	assertInteractiveCapabilities(providerName, capabilities);
+	return capabilities;
+}
+function assertInteractiveCapabilities(providerName, capabilities) {
+	const interactive = capabilities.interactiveAgent;
+	if (!interactive?.start || !interactive.control || !interactive.status || !interactive.attach || !interactive.reattach || !interactive.sendPrompt || !interactive.input || !interactive.resize || !interactive.stop) throw new Error(`provider "${providerName}" cannot control an exact interactive agent`);
+}
+function assertInteractiveMethods(providerName, environment) {
+	if (!environment.startInteractive || !environment.interactive) throw new Error(`provider "${providerName}" exposes incomplete interactive agent controls`);
+}
+async function destroyUnusedEnvironment(environment, cause) {
+	try {
+		await destroyInteractiveEnvironment(environment);
+	} catch (cleanupError) {
+		throw new AggregateError([cause, cleanupError], "interactive environment was invalid and could not be destroyed");
+	}
+}
+//#endregion
+//#region src/runtime/supervise/worker-interactive.ts
+const WORKER_BINDING_SCHEMA_VERSION = 1;
+const SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
+/** Directory containing exact per-worker interactive binding records. @stable */
+function workerInteractiveBindingsDir(eventDir) {
+	return join(eventDir, "interactive-workers");
+}
+/** Exact durable binding file for one worker id. @stable */
+function workerInteractiveBindingFile(eventDir, workerId) {
+	const id = stableText$1(workerId, "worker id");
+	const stem = createHash("sha256").update(id).digest("hex");
+	return join(workerInteractiveBindingsDir(eventDir), `${stem}.json`);
+}
+/** Read and validate one exact durable worker binding. @stable */
+function readWorkerInteractiveBinding(eventDir, workerId) {
+	const id = stableText$1(workerId, "worker id");
+	const file = workerInteractiveBindingFile(eventDir, id);
+	assertNoSymlinkDescendant(eventDir, file, "worker interactive");
+	if (!existsSync(file)) return void 0;
+	const binding = parseBinding(JSON.parse(readFileSync(file, "utf8")));
+	if (binding.workerId !== id) throw new Error(`worker interactive binding collision: '${file}' holds '${binding.workerId}', not '${id}'`);
+	return binding;
+}
+/**
+* Publish the exact interactive capability of one worker after its spawn record commits.
+* Replays of the same binding are no-ops; a different binding for one worker fails loud.
+* @internal
+*/
+function writeWorkerInteractiveBinding(eventDir, workerId, label, journalRoot, session, now = Date.now) {
+	const id = stableText$1(workerId, "worker id");
+	const workerLabel = stableText$1(label, "worker label");
+	const root = stableText$1(journalRoot, "journal root");
+	const binding = session.status === "available" ? (() => {
+		const ref = AgentInteractiveSessionRefSchema.parse(session.handle.ref);
+		return {
+			schemaVersion: WORKER_BINDING_SCHEMA_VERSION,
+			workerId: id,
+			label: workerLabel,
+			journalRoot: root,
+			recordedAt: new Date(now()).toISOString(),
+			status: "available",
+			ref,
+			refDigest: canonicalCandidateDigest(ref)
+		};
+	})() : {
+		schemaVersion: WORKER_BINDING_SCHEMA_VERSION,
+		workerId: id,
+		label: workerLabel,
+		journalRoot: root,
+		recordedAt: new Date(now()).toISOString(),
+		status: "unavailable",
+		reason: session.reason
+	};
+	const file = workerInteractiveBindingFile(eventDir, id);
+	assertNoSymlinkDescendant(eventDir, file, "worker interactive");
+	mkdirSync(dirname(file), { recursive: true });
+	assertNoSymlinkDescendant(eventDir, file, "worker interactive");
+	const existing = readWorkerInteractiveBinding(eventDir, id);
+	if (existing !== void 0) {
+		assertSameBinding(existing, binding);
+		return existing;
+	}
+	if (publishExclusiveDurableFile(file, `${JSON.stringify(binding, null, 2)}\n`)) return binding;
+	const winner = readWorkerInteractiveBinding(eventDir, id);
+	if (winner === void 0) throw new Error(`worker interactive binding publication lost its winner`);
+	assertSameBinding(winner, binding);
+	return winner;
+}
+/**
+* Reconstruct the exact provider-owned interactive process bound to one supervised worker.
+* Unknown, headless, unsupported, settled, stale, and unregistered-provider cases fail closed.
+* @stable
+*/
+async function attachWorker(eventDir, workerId, options) {
+	const id = stableText$1(workerId, "worker id");
+	options.signal?.throwIfAborted();
+	const binding = readWorkerInteractiveBinding(eventDir, id);
+	if (binding === void 0) {
+		const lifecycle = workerLifecycle(eventDir, id);
+		return unavailable(lifecycle.terminal ? "not-live" : lifecycle.spawned ? "interactive-binding-not-found" : "unknown-node");
+	}
+	try {
+		const node = (await loadSpawnForest(new FileSpawnJournal(join(eventDir, SPAWN_JOURNAL_FILE)), binding.journalRoot)).nodes.find((candidate) => candidate.id === id);
+		if (node === void 0) return unavailable("unknown-node");
+		if (node.status === "done" || node.status === "failed" || node.status === "cancelled") return unavailable("not-live");
+	} catch {
+		return unavailable("interactive-binding-stale");
+	}
+	if (binding.status === "unavailable") return unavailable(binding.reason);
+	const provider = resolveProvider(options.providers, binding.ref.run.provider);
+	if (provider === void 0) return unavailable("interactive-provider-not-registered");
+	let handle;
+	try {
+		handle = await reconnectRetainedInteractiveRun({
+			provider,
+			ref: binding.ref,
+			...options.signal === void 0 ? {} : { signal: options.signal }
+		});
+	} catch (error) {
+		options.signal?.throwIfAborted();
+		if (isUnsupportedProvider(error)) return unavailable("provider-has-no-interactive-contract");
+		return unavailable("interactive-binding-stale");
+	}
+	if (handle === null) return unavailable("interactive-binding-stale");
+	let status;
+	try {
+		status = await handle.status(options.signal === void 0 ? void 0 : { signal: options.signal });
+	} catch {
+		options.signal?.throwIfAborted();
+		return unavailable("interactive-binding-stale");
+	}
+	if (status.state !== "running") return unavailable("interactive-binding-stale");
+	return {
+		status: "available",
+		handle
+	};
+}
+function parseBinding(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("worker interactive binding is malformed");
+	const record = value;
+	if (record.schemaVersion !== WORKER_BINDING_SCHEMA_VERSION || typeof record.workerId !== "string" || record.workerId.length === 0 || typeof record.label !== "string" || record.label.length === 0 || typeof record.journalRoot !== "string" || record.journalRoot.length === 0 || typeof record.recordedAt !== "string") throw new Error("worker interactive binding is malformed");
+	if (record.status === "available") {
+		const ref = AgentInteractiveSessionRefSchema.parse(record.ref);
+		const refDigest = canonicalCandidateDigest(ref);
+		if (record.refDigest !== refDigest) throw new Error("worker interactive binding ref digest does not match its exact ref");
+		return {
+			schemaVersion: WORKER_BINDING_SCHEMA_VERSION,
+			workerId: record.workerId,
+			label: record.label,
+			journalRoot: record.journalRoot,
+			recordedAt: record.recordedAt,
+			status: "available",
+			ref,
+			refDigest
+		};
+	}
+	if (record.status !== "unavailable" || !isUnavailableReason(record.reason)) throw new Error("worker interactive binding is malformed");
+	return {
+		schemaVersion: WORKER_BINDING_SCHEMA_VERSION,
+		workerId: record.workerId,
+		label: record.label,
+		journalRoot: record.journalRoot,
+		recordedAt: record.recordedAt,
+		status: "unavailable",
+		reason: record.reason
+	};
+}
+function assertSameBinding(current, candidate) {
+	const currentMaterial = bindingMaterial(current);
+	const candidateMaterial = bindingMaterial(candidate);
+	if (canonicalCandidateDigest(currentMaterial) !== canonicalCandidateDigest(candidateMaterial)) throw new Error(`worker '${candidate.workerId}' already has a different interactive binding`);
+}
+function bindingMaterial(binding) {
+	return binding.status === "available" ? {
+		schemaVersion: binding.schemaVersion,
+		workerId: binding.workerId,
+		label: binding.label,
+		journalRoot: binding.journalRoot,
+		status: binding.status,
+		ref: binding.ref,
+		refDigest: binding.refDigest
+	} : {
+		schemaVersion: binding.schemaVersion,
+		workerId: binding.workerId,
+		label: binding.label,
+		journalRoot: binding.journalRoot,
+		status: binding.status,
+		reason: binding.reason
+	};
+}
+function workerLifecycle(eventDir, workerId) {
+	let raw;
+	try {
+		raw = readFileSync(join(eventDir, SPAWN_JOURNAL_FILE), "utf8");
+	} catch {
+		return {
+			spawned: false,
+			terminal: false
+		};
+	}
+	let spawned = false;
+	let terminal = false;
+	for (const line of raw.split("\n")) {
+		const text = line.trim();
+		if (!text) continue;
+		try {
+			const record = JSON.parse(text);
+			if (record.kind !== "event" || record.event?.id !== workerId) continue;
+			if (record.event.kind === "spawned") spawned = true;
+			if (record.event.kind === "settled" || record.event.kind === "cancelled") terminal = true;
+		} catch {}
+	}
+	return {
+		spawned,
+		terminal
+	};
+}
+function resolveProvider(source, name) {
+	if ("register" in source) return source.get(name);
+	return source.name === name ? source : void 0;
+}
+function unavailable(reason) {
+	return {
+		status: "unavailable",
+		reason
+	};
+}
+function stableText$1(value, label) {
+	const text = value.trim();
+	if (!text) throw new Error(`${label} is empty`);
+	return text;
+}
+function isUnsupportedProvider(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("cannot reconstruct an environment") || message.includes("cannot control an exact interactive agent") || message.includes("incomplete interactive agent controls");
+}
+function isUnavailableReason(value) {
+	return value === "unknown-node" || value === "not-live" || value === "executor-exposes-no-interactive-session" || value === "provider-has-no-interactive-contract" || value === "interactive-session-not-started" || value === "interactive-binding-not-found" || value === "interactive-binding-stale" || value === "interactive-provider-not-registered";
+}
+//#endregion
+//#region src/runtime/supervise/interactive-admission.ts
+/**
+* Durable, credential-free admissions for Runtime-owned interactive workers.
+*
+* `startRetainedInteractiveRun` deliberately asks its caller to persist each admission before it
+* advances. A supervised worker supplies this hook through `Scope`; the hook stores only recovery
+* coordinates and digests, never the profile, prompt, environment variables, or other private
+* create material.
+*/
+/** The Scope seam key used by `workerFromInteractiveProvider`. */
+const interactiveAdmissionSeamKey = "runtime.interactiveAdmission";
+/** Return the exact credential-free admission file for one worker and phase. */
+function workerInteractiveAdmissionFile(eventDir, workerId, phase) {
+	const dir = workerInteractiveBindingsDir(eventDir);
+	const id = stableText(workerId, "worker id");
+	assertNoSymlinkDescendant(eventDir, dir, "interactive admission");
+	return join(dir, `${canonicalCandidateDigest({ workerId: id }).slice(7).slice(0, 32)}.${phase}.admission.json`);
+}
+/** Read all durable admissions for one worker, oldest phase first. */
+function readWorkerInteractiveAdmissions(eventDir, workerId) {
+	const phases = [
+		"interactive_intent",
+		"interactive_environment",
+		"interactive_started"
+	];
+	const admissions = [];
+	let missingPhase = false;
+	for (const phase of phases) {
+		const file = workerInteractiveAdmissionFile(eventDir, workerId, phase);
+		if (!existsSync(file)) {
+			missingPhase = true;
+			continue;
+		}
+		if (missingPhase) throw new Error(`interactive admission phase '${phase}' exists after a missing earlier phase`);
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		admissions.push(parseAdmission(parsed, workerId, phase));
+	}
+	return admissions;
+}
+/**
+* Persist one retained-interactive admission without retaining sensitive start material.
+*
+* The phase file is an idempotency key. A retry with the same exact admission is a no-op; a
+* different admission for the same phase fails closed rather than overwriting recovery evidence.
+*/
+function writeWorkerInteractiveAdmission(eventDir, workerId, admission, now = Date.now) {
+	const id = stableText(workerId, "worker id");
+	const record = credentialFreeAdmission(id, admission, now);
+	const file = workerInteractiveAdmissionFile(eventDir, id, record.phase);
+	assertNoSymlinkDescendant(eventDir, file, "interactive admission");
+	mkdirSync(dirname(file), { recursive: true });
+	assertNoSymlinkDescendant(eventDir, file, "interactive admission");
+	const existing = readWorkerInteractiveAdmission(eventDir, id, record.phase);
+	if (existing !== void 0) {
+		assertSameAdmission(existing, record);
+		return existing;
+	}
+	if (publishExclusiveDurableFile(file, `${JSON.stringify(record, null, 2)}\n`)) return record;
+	const winner = readWorkerInteractiveAdmission(eventDir, id, record.phase);
+	if (winner === void 0) throw new Error(`interactive admission publication for '${record.phase}' lost its winner`);
+	assertSameAdmission(winner, record);
+	return winner;
+}
+function credentialFreeAdmission(workerId, admission, now) {
+	const recordedAt = new Date(now()).toISOString();
+	switch (admission.phase) {
+		case "interactive_intent": return {
+			schemaVersion: 1,
+			workerId,
+			recordedAt,
+			phase: admission.phase,
+			provider: admission.provider,
+			idempotencyKey: admission.idempotencyKey,
+			interactiveIdempotencyKey: admission.interactiveIdempotencyKey,
+			sessionId: admission.sessionId,
+			executionId: admission.executionId,
+			runId: admission.runId,
+			requestedProfileDigest: admission.requestedProfileDigest,
+			requestDigest: admission.requestDigest
+		};
+		case "interactive_environment": return {
+			schemaVersion: 1,
+			workerId,
+			recordedAt,
+			phase: admission.phase,
+			provider: admission.provider,
+			environmentId: admission.environmentId,
+			idempotencyKey: admission.idempotencyKey,
+			interactiveIdempotencyKey: admission.interactiveIdempotencyKey,
+			requestDigest: canonicalCandidateDigest(admission.request)
+		};
+		case "interactive_started": return {
+			schemaVersion: 1,
+			workerId,
+			recordedAt,
+			phase: admission.phase,
+			idempotencyKey: admission.idempotencyKey,
+			interactiveIdempotencyKey: admission.interactiveIdempotencyKey,
+			ref: admission.ref,
+			refDigest: canonicalCandidateDigest(admission.ref)
+		};
+	}
+}
+function readWorkerInteractiveAdmission(eventDir, workerId, phase) {
+	const file = workerInteractiveAdmissionFile(eventDir, workerId, phase);
+	if (!existsSync(file)) return void 0;
+	return parseAdmission(JSON.parse(readFileSync(file, "utf8")), workerId, phase);
+}
+function parseAdmission(value, expectedWorkerId, expectedPhase) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("interactive admission is malformed");
+	const record = value;
+	if (record.schemaVersion !== 1 || typeof record.workerId !== "string" || record.workerId.length === 0 || typeof record.recordedAt !== "string" || !Number.isFinite(Date.parse(record.recordedAt))) throw new Error("interactive admission is malformed");
+	if (expectedWorkerId !== void 0 && record.workerId !== expectedWorkerId) throw new Error("interactive admission worker id does not match its file");
+	if (record.phase === "interactive_intent") {
+		assertAllowedFields(record, [
+			"schemaVersion",
+			"workerId",
+			"recordedAt",
+			"phase",
+			"provider",
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"sessionId",
+			"executionId",
+			"runId",
+			"requestedProfileDigest",
+			"requestDigest"
+		]);
+		assertStrings(record, [
+			"provider",
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"sessionId",
+			"executionId",
+			"runId",
+			"requestedProfileDigest",
+			"requestDigest"
+		]);
+		assertDigest(record.requestedProfileDigest, "interactive admission profile digest");
+		assertDigest(record.requestDigest, "interactive admission request digest");
+		assertPhase(record.phase, expectedPhase);
+		return {
+			schemaVersion: 1,
+			workerId: record.workerId,
+			recordedAt: record.recordedAt,
+			phase: record.phase,
+			provider: record.provider,
+			idempotencyKey: record.idempotencyKey,
+			interactiveIdempotencyKey: record.interactiveIdempotencyKey,
+			sessionId: record.sessionId,
+			executionId: record.executionId,
+			runId: record.runId,
+			requestedProfileDigest: record.requestedProfileDigest,
+			requestDigest: record.requestDigest
+		};
+	}
+	if (record.phase === "interactive_environment") {
+		assertAllowedFields(record, [
+			"schemaVersion",
+			"workerId",
+			"recordedAt",
+			"phase",
+			"provider",
+			"environmentId",
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"requestDigest"
+		]);
+		assertStrings(record, [
+			"provider",
+			"environmentId",
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"requestDigest"
+		]);
+		assertDigest(record.requestDigest, "interactive admission environment request digest");
+		assertPhase(record.phase, expectedPhase);
+		return {
+			schemaVersion: 1,
+			workerId: record.workerId,
+			recordedAt: record.recordedAt,
+			phase: record.phase,
+			provider: record.provider,
+			environmentId: record.environmentId,
+			idempotencyKey: record.idempotencyKey,
+			interactiveIdempotencyKey: record.interactiveIdempotencyKey,
+			requestDigest: record.requestDigest
+		};
+	}
+	if (record.phase === "interactive_started") {
+		assertAllowedFields(record, [
+			"schemaVersion",
+			"workerId",
+			"recordedAt",
+			"phase",
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"ref",
+			"refDigest"
+		]);
+		assertStrings(record, [
+			"idempotencyKey",
+			"interactiveIdempotencyKey",
+			"refDigest"
+		]);
+		const ref = AgentInteractiveSessionRefSchema.parse(record.ref);
+		const refDigest = canonicalCandidateDigest(ref);
+		if (record.refDigest !== refDigest) throw new Error("interactive admission ref digest does not match its exact ref");
+		assertPhase(record.phase, expectedPhase);
+		return {
+			schemaVersion: 1,
+			workerId: record.workerId,
+			recordedAt: record.recordedAt,
+			phase: record.phase,
+			idempotencyKey: record.idempotencyKey,
+			interactiveIdempotencyKey: record.interactiveIdempotencyKey,
+			ref,
+			refDigest
+		};
+	}
+	throw new Error("interactive admission has an invalid phase");
+}
+function assertDigest(value, label) {
+	if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(value)) throw new Error(`${label} is malformed`);
+}
+function assertPhase(phase, expected) {
+	if (expected !== void 0 && phase !== expected) throw new Error("interactive admission phase does not match its file");
+}
+function assertStrings(record, keys) {
+	for (const key of keys) if (typeof record[key] !== "string" || record[key].length === 0) throw new Error(`interactive admission field '${key}' is invalid`);
+}
+function assertAllowedFields(record, allowed) {
+	const fields = new Set(allowed);
+	const unsupported = Object.keys(record).filter((key) => !fields.has(key));
+	if (unsupported.length > 0) throw new Error(`interactive admission contains unsupported fields: ${unsupported.join(", ")}`);
+}
+function assertSameAdmission(current, candidate) {
+	const comparable = (value) => {
+		const { recordedAt: _recordedAt, ...stable } = value;
+		return stable;
+	};
+	if (canonicalCandidateDigest(comparable(current)) !== canonicalCandidateDigest(comparable(candidate))) throw new Error(`worker '${candidate.workerId}' already has a different ${candidate.phase} admission`);
+}
+function stableText(value, label) {
+	const text = value.trim();
+	if (!text) throw new Error(`${label} is empty`);
+	return text;
+}
+//#endregion
 //#region src/runtime/supervise/wait.ts
 /**
 *
@@ -11070,6 +12596,7 @@ function makeNestedScopeSeam(args, liveWorkerCapacity, childNodeId, childBudget,
 				...args.hooks ? { hooks: args.hooks } : {},
 				...args.workerTrace ? { workerTrace: args.workerTrace } : {},
 				...args.workerTraceUnpropagated ? { workerTraceUnpropagated: args.workerTraceUnpropagated } : {},
+				...args.interactiveBindingDir ? { interactiveBindingDir: args.interactiveBindingDir } : {},
 				...deferredOwner.ownerMaterialization === void 0 ? {} : { ownerMaterialization: deferredOwner.ownerMaterialization }
 			});
 		}
@@ -11078,6 +12605,7 @@ function makeNestedScopeSeam(args, liveWorkerCapacity, childNodeId, childBudget,
 /** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
 function createScope(args) {
 	const children = /* @__PURE__ */ new Map();
+	const interactiveBindingDir = args.interactiveBindingDir;
 	const liveWorkerCapacity = args.liveWorkerCapacity ?? {
 		max: normalizeLiveWorkerLimit(args.maxLiveWorkers),
 		live: 0
@@ -11086,6 +12614,7 @@ function createScope(args) {
 	let cursorSeq = args.resumeFrom ? args.resumeFrom.maxCursorSeq + 1 : 0;
 	let waitOrdinal = args.resumeFrom ? args.resumeFrom.maxWaitOrdinal + 1 : 0;
 	let meterSeq = 0;
+	let progressSeq = 0;
 	const now = args.now ?? Date.now;
 	const unclaimedWaits = new Map((args.resumeFrom?.waits ?? []).map((w) => [w.label, w]));
 	const keyed = /* @__PURE__ */ new Map();
@@ -11257,7 +12786,8 @@ function createScope(args) {
 				seams: {
 					...args.seams,
 					[nestedScopeSeamKey]: makeNestedScopeSeam(args, liveWorkerCapacity, id, opts.budget, childDeadlineAtMs, deferredOwner),
-					...workerTrace ? { [workerTraceSeamKey]: workerTrace } : {}
+					...workerTrace ? { [workerTraceSeamKey]: workerTrace } : {},
+					...interactiveBindingDir ? { [interactiveAdmissionSeamKey]: (admission) => Promise.resolve(writeWorkerInteractiveAdmission(interactiveBindingDir, id, admission, now)).then(() => void 0) } : {}
 				}
 			};
 			const executor = resolved.value(spec, ctx);
@@ -11303,6 +12833,7 @@ function createScope(args) {
 				...executor.progress ? { readProgress: executor.progress.bind(executor) } : {},
 				...executor.traceSource ? { readTraceSource: executor.traceSource.bind(executor) } : {},
 				...executor.interactive ? { readInteractive: executor.interactive.bind(executor) } : {},
+				...executor.interactiveReady ? { readInteractiveReady: executor.interactiveReady.bind(executor) } : {},
 				...executor.cancel ? { requestCancel: executor.cancel.bind(executor) } : {},
 				abortChild: (reason) => controller.abort(reason)
 			};
@@ -11465,12 +12996,29 @@ function createScope(args) {
 					startedAt
 				}
 			}, { signal: args.signal });
-			live.settled = runChild(live, executor, controller, task, opts, args.pool, reservation.ticket, args.blobs, now, materializationCommitted, {
+			const childRun = runChild(live, executor, controller, task, opts, args.pool, reservation.ticket, args.blobs, now, args.journal, args.root, () => progressSeq++, materializationCommitted, {
 				complete: async () => pendingEvidence?.complete(),
 				fail: async () => pendingEvidence?.fail()
-			}, childDeadlineAtMs).then((s) => {
-				live.resolved = s;
-				return s;
+			}, childDeadlineAtMs);
+			const interactiveBindingCommitted = spawnCommitted.then(async () => {
+				if (args.interactiveBindingDir === void 0) return;
+				const immediate = readInteractiveSession(live);
+				if (immediate.status === "available" || immediate.reason !== "interactive-session-not-started" || live.readInteractiveReady === void 0) {
+					writeWorkerInteractiveBinding(args.interactiveBindingDir, id, opts.label, args.root, immediate, now);
+					return;
+				}
+				const ready = await readInteractiveReadyUntilWorkerEnds(live.readInteractiveReady, childRun, controller.signal);
+				if (ready !== void 0 && (ready.status === "available" || ready.reason !== "interactive-session-not-started")) writeWorkerInteractiveBinding(args.interactiveBindingDir, id, opts.label, args.root, ready, now);
+			});
+			live.settled = childRun.then(async (s) => {
+				let resolution = s;
+				try {
+					await interactiveBindingCommitted;
+				} catch {
+					resolution = downRecord("interactive worker binding persistence failed", true, s.trace, s.metered, s.providerModel);
+				}
+				live.resolved = resolution;
+				return resolution;
 			}).finally(() => {
 				if (live.cleanupConfirmed) permit.release();
 				clearChildDeadline?.();
@@ -11732,16 +13280,9 @@ function createScope(args) {
 		const child = children.get(nodeId);
 		if (!child) return noInteractiveSession("unknown-node");
 		if (child.wait || child.executorDone || isTerminalNodeStatus(child.status)) return noInteractiveSession("not-live");
-		if (!child.readInteractive) return noInteractiveSession("executor-exposes-no-interactive-session");
-		let reported;
-		try {
-			reported = child.readInteractive();
-		} catch {
-			return noInteractiveSession("executor-exposes-no-interactive-session");
-		}
-		if (reported?.status === "unavailable" && reported.reason) return reported;
-		if (reported?.status === "available" && reported.handle) return reported;
-		return noInteractiveSession("executor-exposes-no-interactive-session");
+		const session = readInteractiveSession(child);
+		if (args.interactiveBindingDir !== void 0 && session.status === "available") writeWorkerInteractiveBinding(args.interactiveBindingDir, child.id, child.label, args.root, session, now);
+		return session;
 	}
 	async function meterInternal(spend, detail, providerModel, accountingOnly = false) {
 		if (args.signal.aborted) throw new ValidationError("scope.meter: cannot record new driver work after scope abort");
@@ -12213,7 +13754,7 @@ async function finalizeWait(child, settlement, seq, args, now, handle) {
 * applied per child). The reservation is reconciled on EVERY path (success, abort, throw)
 * so the conserved pool can never leak a reservation.
 */
-async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now, executionReady, executionEvidence, deadlineAtMs) {
+async function runChild(live, executor, childAbort, task, opts, pool, ticket, blobs, now, journal, journalRoot, nextProgressSeq, executionReady, executionEvidence, deadlineAtMs) {
 	let reconciled = false;
 	let started = false;
 	let terminalTelemetryCaptured = false;
@@ -12241,15 +13782,22 @@ async function runChild(live, executor, childAbort, task, opts, pool, ticket, bl
 	};
 	try {
 		await executionReady;
-		if (childAbort.signal.aborted) throw abortError(childAbort.signal, "execution aborted");
+		if (childAbort.signal.aborted) throw abortError$1(childAbort.signal, "execution aborted");
 		live.status = "running";
 		started = true;
 		const ran = executor.execute(task, childAbort.signal);
 		let artifact;
 		if (isAsyncIterable(ran)) {
-			const spend = await foldStream(ran, (running) => {
+			const spend = await foldStream(ran, async (running) => {
 				live.spent = running;
 				live.lastActivityAt = now();
+				await journal.appendEvent(journalRoot, {
+					kind: "progress",
+					id: live.id,
+					spend: running,
+					seq: nextProgressSeq(),
+					at: new Date(now()).toISOString()
+				});
 			}, childAbort.signal);
 			live.spent = spend;
 			await executionEvidence.complete();
@@ -12471,7 +14019,7 @@ async function foldStream(stream, onProgress, signal) {
 			if (next.done) break;
 			const ev = next.value;
 			meterUsageEvent(totals, ev);
-			onProgress?.({
+			await onProgress?.({
 				iterations: totals.iterations,
 				tokens: cloneTokenUsage(totals.tokens),
 				...totals.tokensKnown ? {} : { tokensKnown: false },
@@ -12507,7 +14055,7 @@ function preserveUnknownTelemetry(streamed, terminal) {
 async function awaitAbortable(work, signal) {
 	if (signal.aborted) {
 		work.catch(() => void 0);
-		throw abortError(signal, "execution aborted");
+		throw abortError$1(signal, "execution aborted");
 	}
 	return await new Promise((resolve, reject) => {
 		let settled = false;
@@ -12516,7 +14064,7 @@ async function awaitAbortable(work, signal) {
 				if (settled) return;
 				settled = true;
 				cleanup();
-				reject(abortError(signal, "execution aborted"));
+				reject(abortError$1(signal, "execution aborted"));
 			});
 		};
 		const cleanup = () => signal.removeEventListener("abort", onAbort);
@@ -12551,6 +14099,42 @@ function noInteractiveSession(reason) {
 		reason
 	});
 }
+/** Read one executor's declared interactive capability without letting a malformed port escape. */
+function readInteractiveSession(child) {
+	if (!child.readInteractive) return noInteractiveSession("executor-exposes-no-interactive-session");
+	let reported;
+	try {
+		reported = child.readInteractive();
+	} catch {
+		return noInteractiveSession("executor-exposes-no-interactive-session");
+	}
+	if (reported?.status === "unavailable" && reported.reason) return reported;
+	if (reported?.status === "available" && reported.handle) return reported;
+	return noInteractiveSession("executor-exposes-no-interactive-session");
+}
+/** Stop waiting for optional readiness when the worker settles or its lifetime is cancelled. */
+async function readInteractiveReadyUntilWorkerEnds(readReady, workerEnded, signal) {
+	if (signal.aborted) return void 0;
+	let resolveAborted;
+	const aborted = new Promise((resolve) => {
+		resolveAborted = resolve;
+	});
+	const onAbort = () => resolveAborted();
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		const outcome = await Promise.race([
+			Promise.resolve().then(readReady).then((session) => ({
+				kind: "ready",
+				session
+			})),
+			workerEnded.then(() => ({ kind: "ended" }), () => ({ kind: "ended" })),
+			aborted.then(() => ({ kind: "ended" }))
+		]);
+		return outcome.kind === "ready" ? outcome.session : void 0;
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
 function isAsyncIterable(value) {
 	return typeof value === "object" && value !== null && typeof value[Symbol.asyncIterator] === "function";
 }
@@ -13137,7 +14721,7 @@ function describeRejection(error) {
 function createSupervisor() {
 	let attached;
 	async function run(root, task, opts) {
-		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, childSettleGraceMs, resume, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated } = opts;
+		const { budget, rootIdentity, rootMaterialization, runId, journal: journalStore, blobs: blobStore, executors: executorRegistry, probes, maxDepth, maxLiveWorkers, maxRestarts, withinMs, childSettleGraceMs, resume, now: suppliedNow, signal, hooks, workerTrace, workerTraceUnpropagated, interactiveBindingDir } = opts;
 		const input = detachedSnapshot({
 			task,
 			options: {
@@ -13150,7 +14734,8 @@ function createSupervisor() {
 				...maxRestarts === void 0 ? {} : { maxRestarts },
 				...withinMs === void 0 ? {} : { withinMs },
 				...childSettleGraceMs === void 0 ? {} : { childSettleGraceMs },
-				...resume === void 0 ? {} : { resume }
+				...resume === void 0 ? {} : { resume },
+				...interactiveBindingDir === void 0 ? {} : { interactiveBindingDir }
 			}
 		}, "supervisor.run");
 		opts = Object.freeze({
@@ -13163,7 +14748,8 @@ function createSupervisor() {
 			...signal === void 0 ? {} : { signal },
 			...hooks === void 0 ? {} : { hooks },
 			...workerTrace === void 0 ? {} : { workerTrace },
-			...workerTraceUnpropagated === void 0 ? {} : { workerTraceUnpropagated }
+			...workerTraceUnpropagated === void 0 ? {} : { workerTraceUnpropagated },
+			...interactiveBindingDir === void 0 ? {} : { interactiveBindingDir }
 		});
 		task = input.task;
 		const rootAct = root.act.bind(root);
@@ -13271,6 +14857,7 @@ function createSupervisor() {
 				...opts.probes ? { probes: opts.probes } : {},
 				...opts.workerTrace ? { workerTrace: opts.workerTrace } : {},
 				...opts.workerTraceUnpropagated ? { workerTraceUnpropagated: opts.workerTraceUnpropagated } : {},
+				...opts.interactiveBindingDir ? { interactiveBindingDir: opts.interactiveBindingDir } : {},
 				...resumeFrom ? { resumeFrom } : {}
 			});
 			const openScope = scope;
@@ -13703,6 +15290,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createSteerableSandboxSession as $, runWorktreeHarness as $t, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as A, createPropagatingTraceEmitter as At, captureReusableExecutorConfig as B, exportEvalRuns as Bt, timerAt as C, validateProfileMaterialization as Cn, createSandboxLineage as Ct, freeSlots as D, runBrainLoop as Dt, effectiveConcurrency as E, routerBrain as Et, bindReusableExecutorExecutionId as F, buildLoopOtelSpans as Ft, snapshotExecutorConfig as G, padTraceId as Gt, cliWorktreeExecutor as H, generateSpanId as Ht, bridgeAdmissionRead as I, buildLoopSpanNodes as It, readWorkerTraceContext as J, createRuntimeStreamEventCollector as Jt, createWorktreeCliExecutor as K, toOtelAttributes as Kt, bridgeModelRouteRefusal as L, buildRuntimeEventOtelSpans as Lt, assertValidBudget as M, readTraceContextFromEnv as Mt, createBudgetPool as N, traceContextToEnv as Nt, queueOf as O, canonicalObservedModel as Ot, spendFromUsageEvents as P, INTELLIGENCE_WIRE_VERSION as Pt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Q, runSettledCommand as Qt, bridgeRuntimeAttachmentsKey as R, createOpenInferenceFileExporter as Rt, pollFor as S, unsupportedProfileDimensions as Sn, runAgentRounds as St, waitUntil as T, acquireSandbox as Tt, createExecutor as U, loopEventToOtelSpan as Ut, cliInPlaceExecutor as V, flatOtelSpan as Vt, createExecutorRegistry as W, padSpanId as Wt, workerTraceHeaders as X, sanitizeKnowledgeReadinessReport as Xt, workerTraceEnv as Y, sanitizeAgentRuntimeEvent as Yt, workerTraceSeamKey as Z, sanitizeRuntimeStreamEvent as Zt, recordScopeOwnerMaterialization as _, promptOnlyProfileMaterialization as _n, createInPlaceCliExecutor as _t, uncertainSpawnBudgets as a, harnessSupportsReasoningEffort as an, readWorkerProgress as at, createWaitProbes as b, renderUnsupported as bn, defaultSelectWinner as bt, pickBestDelivered as c, CodexExecutionDiagnosticError as cn, DEFAULT_PEER_MAIL_LIMITS as ct, driverChild as d, controlProfileMaterialization as dn, createPeerMailbox as dt, captureWorktreeDiff as en, createPushTraceSource as et, withDriverExecutor as f, defineProfileMaterializationContract as fn, isPeerMailEnvelope as ft, meterRuntimeOwnedProviderAttempt as g, promptModelProfileMaterialization as gn, isTerminalNodeStatus as gt, meterRuntimeOwnedAccounting as h, promptControlProfileMaterialization as hn, isLiveNodeStatus as ht, sumMeasuredSpendFromEvents as i, LOCAL_HARNESSES as in, createActivityLog as it, teardownExecutor as j, mergeTraceEnv as jt, rollingDispatch as k, observedModelMatchesDeclared as kt, runFinalizer as l, AGENT_PROFILE_MATERIALIZATION_AXES as ln, PEER_MAIL_WIRE_KEY as lt, deriveNodeExecutionIdentity as m, profileMaterializationAxes$1 as mn, peerMailVerbNames as mt, createSupervisor as n, removeWorktree as nn, sandboxSessionTraceSource as nt, bestDelivered as o, localHarnessExecutable as on, createInbox as ot, createScope as p, fullProfileMaterialization as pn, peerMailTools as pt, WORKER_TRACE_PROPAGATION as q, createRuntimeEventCollector as qt, maxSeqOf as r, DEFAULT_LOCAL_HARNESS as rn, DEFAULT_STALL_AFTER_MS as rt, collectDelivered as s, parseCodexTokenUsage as sn, AUTHORITY_MARKERS as st, createRootHandle as t, createWorktree as tn, decodeToolPart as tt, runTree as u, assertProfileMaterialization as un, claimsAuthority as ut, scopeOwnerExecutorNodeContext as v, promptResourceProfileMaterialization as vn, TERMINAL_DECISIONS as vt, validateWaitSpec as w, worktreeCliProfileMaterialization as wn, probeSandboxCapabilities as wt, isWaitOutcome as x, sandboxActProfileMaterialization as xn, isTerminalDecision as xt, settledToIteration as y, renderProfileMaterializationIssues as yn, createSandboxForSpec as yt, bridgeStopSignalKey as z, createOtelExporter as zt };
+export { bridgeRuntimeAttachmentsKey as $, buildRuntimeEventOtelSpans as $t, readWorkerInteractiveBinding as A, profileMaterializationAxes$1 as An, isLiveNodeStatus as At, retainedCreateMaterial as B, worktreeCliProfileMaterialization as Bn, probeSandboxCapabilities as Bt, timerAt as C, parseCodexTokenUsage as Cn, DEFAULT_PEER_MAIL_LIMITS as Ct, readWorkerInteractiveAdmissions as D, controlProfileMaterialization as Dn, isPeerMailEnvelope as Dt, interactiveAdmissionSeamKey as E, assertProfileMaterialization as En, createPeerMailbox as Et, startRetainedInteractiveRun as F, renderProfileMaterializationIssues as Fn, createSandboxForSpec as Ft, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as G, observedModelMatchesDeclared as Gt, freeSlots as H, routerBrain as Ht, reconnectRetainedRun as I, renderUnsupported as In, defaultSelectWinner as It, createBudgetPool as J, readTraceContextFromEnv as Jt, teardownExecutor as K, createPropagatingTraceEmitter as Kt, recoverRetainedRun as L, sandboxActProfileMaterialization as Ln, isTerminalDecision as Lt, workerInteractiveBindingsDir as M, promptModelProfileMaterialization as Mn, createInPlaceCliExecutor as Mt, reconnectRetainedInteractiveRun as N, promptOnlyProfileMaterialization as Nn, taskToPrompt as Nt, workerInteractiveAdmissionFile as O, defineProfileMaterializationContract as On, peerMailTools as Ot, recoverRetainedInteractiveRun as P, promptResourceProfileMaterialization as Pn, TERMINAL_DECISIONS as Pt, bridgeModelRouteRefusal as Q, buildLoopSpanNodes as Qt, startRetainedRun as R, unsupportedProfileDimensions as Rn, runAgentRounds as Rt, pollFor as S, localHarnessExecutable as Sn, AUTHORITY_MARKERS as St, waitUntil as T, AGENT_PROFILE_MATERIALIZATION_AXES as Tn, claimsAuthority as Tt, queueOf as U, runBrainLoop as Ut, effectiveConcurrency as V, acquireSandbox as Vt, rollingDispatch as W, canonicalObservedModel as Wt, bindReusableExecutorExecutionId as X, INTELLIGENCE_WIRE_VERSION as Xt, spendFromUsageEvents as Y, traceContextToEnv as Yt, bridgeAdmissionRead as Z, buildLoopOtelSpans as Zt, recordScopeOwnerMaterialization as _, createWorktree as _n, sandboxSessionTraceSource as _t, uncertainSpawnBudgets as a, loopEventToOtelSpan as an, createExecutorRegistry as at, createWaitProbes as b, LOCAL_HARNESSES as bn, readWorkerProgress as bt, pickBestDelivered as c, toOtelAttributes as cn, WORKER_TRACE_PROPAGATION as ct, driverChild as d, sanitizeAgentRuntimeEvent as dn, workerTraceHeaders as dt, createOpenInferenceFileExporter as en, bridgeStopSignalKey as et, withDriverExecutor as f, sanitizeKnowledgeReadinessReport as fn, workerTraceSeamKey as ft, meterRuntimeOwnedProviderAttempt as g, captureWorktreeDiff as gn, decodeToolPart as gt, meterRuntimeOwnedAccounting as h, runWorktreeHarness as hn, createPushTraceSource as ht, sumMeasuredSpendFromEvents as i, generateSpanId as in, createExecutor as it, workerInteractiveBindingFile as j, promptControlProfileMaterialization as jn, isTerminalNodeStatus as jt, attachWorker as k, fullProfileMaterialization as kn, peerMailVerbNames as kt, runFinalizer as l, createRuntimeEventCollector as ln, readWorkerTraceContext as lt, deriveNodeExecutionIdentity as m, runSettledCommand as mn, createSteerableSandboxSession as mt, createSupervisor as n, exportEvalRuns as nn, cliInPlaceExecutor as nt, bestDelivered as o, padSpanId as on, snapshotExecutorConfig as ot, createScope as p, sanitizeRuntimeStreamEvent as pn, DEFAULT_SANDBOX_STEERING_MAX_TURNS as pt, assertValidBudget as q, mergeTraceEnv as qt, maxSeqOf as r, flatOtelSpan as rn, cliWorktreeExecutor as rt, collectDelivered as s, padTraceId as sn, createWorktreeCliExecutor as st, createRootHandle as t, createOtelExporter as tn, captureReusableExecutorConfig as tt, runTree as u, createRuntimeStreamEventCollector as un, workerTraceEnv as ut, scopeOwnerExecutorNodeContext as v, removeWorktree as vn, DEFAULT_STALL_AFTER_MS as vt, validateWaitSpec as w, CodexExecutionDiagnosticError as wn, PEER_MAIL_WIRE_KEY as wt, isWaitOutcome as x, harnessSupportsReasoningEffort as xn, createInbox as xt, settledToIteration as y, DEFAULT_LOCAL_HARNESS as yn, createActivityLog as yt, startRetainedRunInEnvironment as z, validateProfileMaterialization as zn, createSandboxLineage as zt };
 
-//# sourceMappingURL=supervisor-Bt1XLCVq.js.map
+//# sourceMappingURL=supervisor-ChLgoYhG.js.map