@tangle-network/agent-runtime 0.340.0 → 0.342.0

package/dist/{provision-supervisor-DqvWXmAE.js → provision-supervisor-DL6gEMQp.js}

@@ -1,8 +1,8 @@
 import { o as writeAtomicDurableFile } from "./durable-file-gNI9ILAn.js";
-import { An as taskToPrompt, Ht as retainedCreateMaterial, Si as contentAddress, Ur as finalizeRuntimeOwnedPendingExecutor, Ut as destroyInteractiveEnvironment, Wt as environmentGone, bn as createInbox, g as interactiveAdmissionSeamKey, gr as linkAbort, ii as executableAgentProfileSnapshot, n as createSupervisor, o as createRootHandle, qr as newExecutionAttemptId, v as readWorkerInteractiveBinding, vr as signalAbortError, x as startRetainedInteractiveRun, xi as detachedSnapshot, xn as failPendingAfter, zr as attestRuntimeOwnedPendingExecutor } from "./supervisor-VXuN2OHT.js";
-import { Ct as armDeadlineTimer, U as abortError, ot as sleep } from "./sandbox-profile-compat-DRr3JwDx.js";
+import { An as taskToPrompt, Ht as retainedCreateMaterial, Si as contentAddress, Ur as finalizeRuntimeOwnedPendingExecutor, Ut as destroyInteractiveEnvironment, Wt as environmentGone, bn as createInbox, g as interactiveAdmissionSeamKey, gr as linkAbort, ii as executableAgentProfileSnapshot, n as createSupervisor, o as createRootHandle, qr as newExecutionAttemptId, v as readWorkerInteractiveBinding, vr as signalAbortError, x as startRetainedInteractiveRun, xi as detachedSnapshot, xn as failPendingAfter, zr as attestRuntimeOwnedPendingExecutor } from "./supervisor-DUWcecAd.js";
+import { Ct as armDeadlineTimer, U as abortError, ot as sleep } from "./sandbox-profile-compat-FN2kab2-.js";
 import { a as concreteProfileModel } from "./model-policy-CyCUwHed.js";
-import { f as createFileRunContext, n as createSteerAcknowledger, r as createCoordinationTools, t as createCancelAcknowledger } from "./driver-control-acknowledgers-MTrs8HAF.js";
+import { f as createFileRunContext, o as createCancelAcknowledger, s as createSteerAcknowledger, t as createCoordinationTools } from "./coordination-manager-B5JsolDR.js";
 import { g as supervisorRunDir } from "./run-cancellation-C9oL62sW.js";
 import { agentInteractiveSessionControlClaimRequestDigest, agentInteractiveSessionPromptRequestDigest, agentInteractiveSessionStopRequestDigest, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { randomUUID } from "node:crypto";
@@ -58,493 +58,407 @@ function controlClaimOperationId(handle, holderId, expectedGeneration) {
 	}).slice(7, 47)}`;
 }
 //#endregion
-//#region src/runtime/supervise/interactive-worker.ts
+//#region src/runtime/supervise/interactive-executor.ts
 /**
-* Runtime-owned worker seam for a provider's native interactive coding-agent process.
-*
-* This adapter composes the retained-interactive lifecycle. It does not create a second stream,
-* replay buffer, session id, or cancellation protocol. The provider owns process state; Scope owns
-* the supervised worker, journal, budget, and local control inbox.
+* The executor behind one interactive worker: starts the provider's retained interactive process,
+* polls it to exit, relays steers as prompts, and stops and releases it exactly once.
 */
 const INTERACTIVE_TEARDOWN_TIMEOUT_MS = 3e4;
-/**
-* Build a `MakeWorkerAgent` that starts one exact provider-owned native TUI per worker.
-*
-* A Scope supplies the durable admission hook and kernel-minted node attempt. The returned worker
-* exposes `interactiveReady`, so Scope writes the exact provider reference before the worker can be
-* attached by a different process. `attachWorker` then reconnects that same reference through the
-* provider's public `get`/interactive contract.
-*/
-function workerFromInteractiveProvider(provider, options = {}) {
-	if (!provider.name.trim()) throw new Error("workerFromInteractiveProvider: provider.name required");
-	if (!provider.get) throw new Error(`workerFromInteractiveProvider(${provider.name}): provider.get is required for reconnect`);
-	const capturedEnvironment = options.environment ? structuredClone(options.environment) : void 0;
-	const unscopedNamespace = randomUUID();
-	let unscopedOrdinal = 0;
-	const runtime = options.runtime ?? provider.name;
-	return (rawProfile, spawnContext) => {
-		const profile = executableAgentProfileSnapshot(rawProfile, `workerFromInteractiveProvider(${provider.name})`);
-		const input = {
-			provider: provider.name,
-			profile,
-			...spawnContext === void 0 ? {} : { context: spawnContext }
-		};
-		const assignmentId = spawnContext?.assignmentId ?? `unscoped:${unscopedNamespace}:${unscopedOrdinal++}`;
-		const baseInput = {
-			...input,
-			nodeId: spawnContext?.parentNodeId
-		};
-		const environmentKey = stableKey(options.environmentIdempotencyKey?.({ ...baseInput }) ?? derivedKey("supervised-interactive-environment", {
-			provider: provider.name,
-			assignmentId,
-			parentNodeId: spawnContext?.parentNodeId,
-			profile
-		}), "environment idempotency key");
-		const name = profile.name ?? "interactive-worker";
-		const executorFactory = (spec, ctx) => interactiveExecutor({
-			provider,
-			profile: spec.profile,
-			context: spawnContext,
-			environment: capturedEnvironment,
-			environmentKey,
-			interactiveKey: (task) => stableKey(options.interactiveIdempotencyKey?.({
-				...baseInput,
-				task
-			}) ?? derivedKey("supervised-interactive-session", {
-				provider: provider.name,
-				assignmentId,
-				parentNodeId: spawnContext?.parentNodeId,
-				profile: spec.profile,
-				task
-			}), "interactive idempotency key"),
-			holderId: (task) => {
-				return stableKey((typeof options.holderId === "function" ? options.holderId({
-					...baseInput,
-					task
-				}) : options.holderId) ?? `runtime-interactive-worker:${canonicalCandidateDigest({
-					provider: provider.name,
-					assignmentId
-				})}`, "interactive holder id");
-			},
-			initialPrompt: options.initialPrompt,
-			cwd: options.cwd,
-			cols: options.cols,
-			rows: options.rows,
-			runtime,
-			pollIntervalMs: options.pollIntervalMs,
-			destroyEnvironmentOnTeardown: options.destroyEnvironmentOnTeardown,
-			executionAttemptId: ctx.node?.attemptId,
-			nodeId: ctx.node?.nodeId,
-			admission: admissionWriter(ctx, provider.name, ctx.node?.nodeId)
-		});
-		return {
-			name,
-			act: async () => {
-				throw new Error("workerFromInteractiveProvider: interactive workers execute through executorSpec");
-			},
-			executorSpec: {
-				profile,
-				harness: null,
-				executorFactory,
-				...spawnContext?.execution ? { execution: spawnContext.execution } : {}
-			}
-		};
+const descriptorOf = (input) => ({
+	kind: "interactive-session",
+	provider: input.provider.name,
+	transport: "agent-environment"
+});
+function plannedDeclarationOf(input) {
+	const declaredEnvironment = input.environment ? retainedCreateMaterial({
+		...input.environment,
+		profile: input.profile,
+		idempotencyKey: input.environmentKey
+	}) : null;
+	const profileModel = concreteProfileModel(input.profile);
+	return {
+		effectiveProfile: input.profile,
+		backend: input.provider.name,
+		model: profileModel ? {
+			status: "known",
+			id: profileModel
+		} : {
+			status: "unknown",
+			reason: "provider selected the model"
+		},
+		execution: {
+			kind: "interactive-session",
+			id: input.nodeId ?? input.environmentKey
+		},
+		materializer: "retained-interactive-provider",
+		plan: {
+			kind: "retained-interactive-provider",
+			provider: input.provider.name,
+			environment: declaredEnvironment,
+			environmentIdempotencyKey: input.environmentKey,
+			destroyEnvironmentOnTeardown: input.destroyEnvironmentOnTeardown !== false
+		}
 	};
 }
 function interactiveExecutor(input) {
 	const attemptId = input.executionAttemptId ?? newExecutionAttemptId(input.nodeId ?? input.environmentKey);
-	const localController = new AbortController();
-	const inbox = createInbox();
-	let handle;
-	let createdEnvironment;
-	let environmentId;
-	let artifact;
-	let activeLink;
-	let startPromise;
-	let executeStarted = false;
-	let readyResolve;
+	let resolveReady;
 	const ready = new Promise((resolve) => {
-		readyResolve = resolve;
+		resolveReady = resolve;
 	});
-	const stopOperations = /* @__PURE__ */ new Map();
-	const memoryAdmissions = /* @__PURE__ */ new Map();
-	let teardownComplete = false;
-	let teardownPromise;
-	let flushChain = Promise.resolve();
-	let controlError;
-	const executor = {
+	const run = {
+		input,
+		attemptId,
+		localController: new AbortController(),
+		inbox: createInbox(),
+		planned: plannedDeclarationOf(input),
+		stopOperations: /* @__PURE__ */ new Map(),
+		memoryAdmissions: /* @__PURE__ */ new Map(),
+		ready,
+		resolveReady,
+		executor: void 0,
+		handle: void 0,
+		createdEnvironment: void 0,
+		environmentId: void 0,
+		artifact: void 0,
+		activeLink: void 0,
+		startPromise: void 0,
+		executeStarted: false,
+		teardownComplete: false,
+		teardownPromise: void 0,
+		flushChain: Promise.resolve(),
+		controlError: void 0
+	};
+	run.executor = interactiveSurface(run);
+	attestRuntimeOwnedPendingExecutor(run.executor, input.runtime, run.planned, {
+		attemptId,
+		binding: {
+			provider: input.provider.name,
+			environmentIdempotencyKey: input.environmentKey,
+			nodeId: input.nodeId ?? null
+		},
+		descriptor: descriptorOf(input)
+	});
+	return run.executor;
+}
+function interactiveSurface(run) {
+	const { input } = run;
+	return {
 		runtime: input.runtime,
 		teardownTimeoutMs: INTERACTIVE_TEARDOWN_TIMEOUT_MS,
 		execute(task, signal) {
-			if (executeStarted || teardownComplete || teardownPromise !== void 0) throw new Error("workerFromInteractiveProvider: execute() may only be called once");
-			executeStarted = true;
-			startPromise = startInteractive(task, signal);
-			return failPendingAfter(inbox, runInteractive(signal));
+			if (run.executeStarted || run.teardownComplete || run.teardownPromise !== void 0) throw new Error("workerFromInteractiveProvider: execute() may only be called once");
+			run.executeStarted = true;
+			run.startPromise = startInteractive(run, task, signal);
+			return failPendingAfter(run.inbox, runInteractive(run, signal));
 		},
 		deliver(message) {
-			if (teardownComplete || teardownPromise !== void 0) return false;
-			const accepted = inbox.deliver(message);
-			if (accepted) flushInbox();
+			if (run.teardownComplete || run.teardownPromise !== void 0) return false;
+			const accepted = run.inbox.deliver(message);
+			if (accepted) flushInbox(run);
 			return accepted;
 		},
 		interactive() {
-			return handle ? {
+			return run.handle ? {
 				status: "available",
-				handle
+				handle: run.handle
 			} : {
 				status: "unavailable",
 				reason: "interactive-session-not-started"
 			};
 		},
 		interactiveReady() {
-			return ready;
+			return run.ready;
 		},
 		async cancel(request) {
-			const existing = stopOperations.get(request.operationId);
+			const existing = run.stopOperations.get(request.operationId);
 			if (existing) return existing;
-			const tracked = stopInteractive(request.operationId, request.reason, request.signal).then((result) => {
-				if (result.status === "unknown" && stopOperations.get(request.operationId) === tracked) stopOperations.delete(request.operationId);
+			const tracked = stopInteractive(run, request.operationId, request.reason, request.signal).then((result) => {
+				if (result.status === "unknown" && run.stopOperations.get(request.operationId) === tracked) run.stopOperations.delete(request.operationId);
 				return result;
 			});
-			stopOperations.set(request.operationId, tracked);
+			run.stopOperations.set(request.operationId, tracked);
 			return tracked;
 		},
 		teardown(grace) {
-			if (teardownComplete) return Promise.resolve({ destroyed: true });
-			if (teardownPromise !== void 0) return teardownPromise;
-			teardownPromise = teardownInteractive().then((result) => {
-				teardownComplete = true;
+			if (run.teardownComplete) return Promise.resolve({ destroyed: true });
+			if (run.teardownPromise !== void 0) return run.teardownPromise;
+			run.teardownPromise = teardownInteractive(run).then((result) => {
+				run.teardownComplete = true;
 				return result;
 			}, (error) => {
-				teardownPromise = void 0;
+				run.teardownPromise = void 0;
 				throw error;
 			});
-			return teardownPromise;
+			return run.teardownPromise;
 		},
 		heldEnvironments() {
-			if (teardownComplete || input.destroyEnvironmentOnTeardown === false) return [];
-			const held = createdEnvironment?.id ?? environmentId ?? handle?.ref.run.environmentId;
+			if (run.teardownComplete || input.destroyEnvironmentOnTeardown === false) return [];
+			const held = run.createdEnvironment?.id ?? run.environmentId ?? run.handle?.ref.run.environmentId;
 			return held === void 0 ? [] : [{
 				provider: input.provider.name,
 				environmentId: held
 			}];
 		},
 		resultArtifact() {
-			if (!artifact) throw new Error("workerFromInteractiveProvider: resultArtifact() read before execution settled");
-			return artifact;
+			if (!run.artifact) throw new Error("workerFromInteractiveProvider: resultArtifact() read before execution settled");
+			return run.artifact;
 		}
 	};
-	const declaredEnvironment = input.environment ? retainedCreateMaterial({
-		...input.environment,
+}
+function initialPromptFor(input, task) {
+	const initialPrompt = typeof input.initialPrompt === "function" ? input.initialPrompt(task, {
+		provider: input.provider.name,
 		profile: input.profile,
-		idempotencyKey: input.environmentKey
-	}) : null;
-	const profileModel = concreteProfileModel(input.profile);
-	const plannedDeclaration = {
-		effectiveProfile: input.profile,
-		backend: input.provider.name,
-		model: profileModel ? {
-			status: "known",
-			id: profileModel
-		} : {
-			status: "unknown",
-			reason: "provider selected the model"
-		},
-		execution: {
-			kind: "interactive-session",
-			id: input.nodeId ?? input.environmentKey
-		},
-		materializer: "retained-interactive-provider",
-		plan: {
-			kind: "retained-interactive-provider",
-			provider: input.provider.name,
-			environment: declaredEnvironment,
-			environmentIdempotencyKey: input.environmentKey,
-			destroyEnvironmentOnTeardown: input.destroyEnvironmentOnTeardown !== false
-		}
-	};
-	attestRuntimeOwnedPendingExecutor(executor, input.runtime, plannedDeclaration, {
-		attemptId,
-		binding: {
-			provider: input.provider.name,
-			environmentIdempotencyKey: input.environmentKey,
-			nodeId: input.nodeId ?? null
-		},
-		descriptor: {
-			kind: "interactive-session",
-			provider: input.provider.name,
-			transport: "agent-environment"
-		}
-	});
-	async function startInteractive(task, signal) {
-		try {
-			activeLink = linkAbort(signal, localController.signal);
-			const initialPrompt = typeof input.initialPrompt === "function" ? input.initialPrompt(task, {
-				provider: input.provider.name,
-				profile: input.profile,
-				...input.context === void 0 ? {} : { context: input.context },
-				task,
-				...input.nodeId === void 0 ? {} : { nodeId: input.nodeId }
-			}) : input.initialPrompt ?? taskToPrompt(task);
-			if (typeof initialPrompt !== "string") throw new Error("workerFromInteractiveProvider: initialPrompt must return a string");
-			const interactiveIdempotencyKey = input.interactiveKey(task);
-			const started = await startRetainedInteractiveRun({
-				provider: {
-					...input.provider,
-					async create(environmentInput) {
-						const environment = await input.provider.create(environmentInput);
-						createdEnvironment = environment;
-						return environment;
-					}
-				},
-				environment: {
-					...input.environment ?? {},
-					profile: input.profile,
-					idempotencyKey: input.environmentKey
-				},
-				interactiveIdempotencyKey,
-				...initialPrompt.length === 0 ? {} : { initialPrompt },
-				...input.cwd === void 0 ? {} : { cwd: input.cwd },
-				...input.cols === void 0 ? {} : { cols: input.cols },
-				...input.rows === void 0 ? {} : { rows: input.rows },
-				onAdmission: async (admission) => {
-					environmentId = admission.phase === "interactive_environment" ? admission.environmentId : environmentId;
-					const existing = memoryAdmissions.get(admission.phase);
-					if (existing !== void 0) {
-						if (canonicalCandidateDigest(existing) !== canonicalCandidateDigest(admission)) throw new Error(`interactive admission phase '${admission.phase}' changed across retry`);
-					} else memoryAdmissions.set(admission.phase, detachedSnapshot(admission, "interactive admission"));
-					await input.admission(admission);
-				},
-				signal: activeLink.signal
-			});
-			finalizeRuntimeOwnedPendingExecutor(executor, {
-				...plannedDeclaration,
-				execution: {
-					kind: "interactive-session",
-					id: started.ref.run.executionId
-				},
-				plan: {
-					...plannedDeclaration.plan,
-					environmentId: started.ref.run.environmentId,
-					interactiveIdempotencyKey
-				}
-			}, {
-				attemptId,
-				binding: {
-					provider: input.provider.name,
-					ref: started.ref,
-					environmentId: started.ref.run.environmentId
-				},
-				descriptor: {
-					kind: "interactive-session",
-					provider: input.provider.name,
-					transport: "agent-environment"
+		...input.context === void 0 ? {} : { context: input.context },
+		task,
+		...input.nodeId === void 0 ? {} : { nodeId: input.nodeId }
+	}) : input.initialPrompt ?? taskToPrompt(task);
+	if (typeof initialPrompt !== "string") throw new Error("workerFromInteractiveProvider: initialPrompt must return a string");
+	return initialPrompt;
+}
+/** Keep each admission phase's first snapshot in memory and refuse a retry that changes it. */
+async function recordAdmission(run, admission) {
+	run.environmentId = admission.phase === "interactive_environment" ? admission.environmentId : run.environmentId;
+	const existing = run.memoryAdmissions.get(admission.phase);
+	if (existing !== void 0) {
+		if (canonicalCandidateDigest(existing) !== canonicalCandidateDigest(admission)) throw new Error(`interactive admission phase '${admission.phase}' changed across retry`);
+	} else run.memoryAdmissions.set(admission.phase, detachedSnapshot(admission, "interactive admission"));
+	await run.input.admission(admission);
+}
+async function startInteractive(run, task, signal) {
+	const { input } = run;
+	try {
+		run.activeLink = linkAbort(signal, run.localController.signal);
+		const initialPrompt = initialPromptFor(input, task);
+		const interactiveIdempotencyKey = input.interactiveKey(task);
+		const started = await startRetainedInteractiveRun({
+			provider: {
+				...input.provider,
+				async create(environmentInput) {
+					const environment = await input.provider.create(environmentInput);
+					run.createdEnvironment = environment;
+					return environment;
 				}
-			});
-			handle = started;
-			readyResolve({
-				status: "available",
-				handle: started
-			});
-			flushInbox();
-			return started;
-		} catch (error) {
-			readyResolve({
-				status: "unavailable",
-				reason: unavailableReason(error)
-			});
-			activeLink?.release();
-			throw error;
-		}
-	}
-	async function* runInteractive(signal) {
-		const startedAt = Date.now();
-		try {
-			const current = await startPromise;
-			if (current === void 0) throw new Error("workerFromInteractiveProvider: interactive start did not begin");
-			yield { kind: "iteration" };
-			yield {
-				kind: "tokens",
-				input: 0,
-				output: 0,
-				tokensKnown: false
-			};
-			yield {
-				kind: "cost",
-				usd: 0,
-				usdKnown: false,
-				provenance: "uncaptured"
-			};
-			let status;
-			for (;;) {
-				if (signal.aborted || localController.signal.aborted) throw signalAbortError(signal.aborted ? signal : localController.signal, "interactive execution aborted");
-				status = await current.status({ signal: activeLink?.signal });
-				await flushChain;
-				if (controlError !== void 0) throw controlErrorValue(controlError);
-				if (status.state !== "running") break;
-				await sleep(input.pollIntervalMs ?? 100, activeLink?.signal);
+			},
+			environment: {
+				...input.environment ?? {},
+				profile: input.profile,
+				idempotencyKey: input.environmentKey
+			},
+			interactiveIdempotencyKey,
+			...initialPrompt.length === 0 ? {} : { initialPrompt },
+			...input.cwd === void 0 ? {} : { cwd: input.cwd },
+			...input.cols === void 0 ? {} : { cols: input.cols },
+			...input.rows === void 0 ? {} : { rows: input.rows },
+			onAdmission: (admission) => recordAdmission(run, admission),
+			signal: run.activeLink.signal
+		});
+		finalizeRuntimeOwnedPendingExecutor(run.executor, {
+			...run.planned,
+			execution: {
+				kind: "interactive-session",
+				id: started.ref.run.executionId
+			},
+			plan: {
+				...run.planned.plan,
+				environmentId: started.ref.run.environmentId,
+				interactiveIdempotencyKey
 			}
-			const finished = status;
-			const output = {
+		}, {
+			attemptId: run.attemptId,
+			binding: {
 				provider: input.provider.name,
-				environmentId: current.ref.run.environmentId,
-				sessionId: current.ref.run.sessionId,
-				executionId: current.ref.run.executionId,
-				state: finished?.state === "exited" ? "exited" : "unknown",
-				ref: current.ref,
-				...finished?.state === "exited" && finished.reason ? { reason: finished.reason } : {},
-				...finished?.state === "exited" && finished.exitCode !== void 0 ? { exitCode: finished.exitCode } : {},
-				...finished?.state === "exited" && finished.exitSignal !== void 0 ? { exitSignal: finished.exitSignal } : {}
-			};
-			const spent = {
-				iterations: 1,
-				tokens: {
-					input: 0,
-					output: 0
-				},
-				tokensKnown: false,
-				usd: 0,
-				usdKnown: false,
-				ms: Date.now() - startedAt
-			};
-			artifact = {
-				outRef: contentAddress(output),
-				out: output,
-				spent
-			};
-		} finally {
-			activeLink?.release();
-		}
-	}
-	async function flushInbox() {
-		flushChain = flushChain.then(async () => {
-			if (!handle) return;
-			const lease = inbox.take();
-			try {
-				const messages = lease.messages;
-				if (messages.length === 0) return;
-				const prompt = inbox.fold(messages);
-				const operationId = `interactive-prompt-${canonicalCandidateDigest({
-					ref: handle.ref,
-					prompt
-				}).slice(7)}`;
-				const control = await claimRetainedInteractiveControl({
-					handle,
-					holderId: input.holderId(void 0)
-				});
-				const material = {
-					operationId,
-					ref: handle.ref,
-					control,
-					prompt
-				};
-				const command = {
-					...material,
-					requestDigest: agentInteractiveSessionPromptRequestDigest(material)
-				};
-				await handle.sendPrompt(command);
-				for (const message of messages) lease.commit(operationId, message.id);
-			} catch (error) {
-				lease.release();
-				controlError ??= error;
-			}
+				ref: started.ref,
+				environmentId: started.ref.run.environmentId
+			},
+			descriptor: descriptorOf(input)
+		});
+		run.handle = started;
+		run.resolveReady({
+			status: "available",
+			handle: started
 		});
-		await flushChain;
+		flushInbox(run);
+		return started;
+	} catch (error) {
+		run.resolveReady({
+			status: "unavailable",
+			reason: unavailableReason(error)
+		});
+		run.activeLink?.release();
+		throw error;
 	}
-	async function stopInteractive(operationId, reason, signal) {
-		const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (!handle) {
-			localController.abort(reason ?? "interactive cancellation requested");
-			return {
-				status: "unknown",
-				effect: "cancel_requested",
-				observedAt,
-				detail: "interactive process has not published a provider reference"
-			};
+}
+async function* runInteractive(run, signal) {
+	const { input, localController } = run;
+	const startedAt = Date.now();
+	try {
+		const current = await run.startPromise;
+		if (current === void 0) throw new Error("workerFromInteractiveProvider: interactive start did not begin");
+		yield { kind: "iteration" };
+		yield {
+			kind: "tokens",
+			input: 0,
+			output: 0,
+			tokensKnown: false
+		};
+		yield {
+			kind: "cost",
+			usd: 0,
+			usdKnown: false,
+			provenance: "uncaptured"
+		};
+		let status;
+		for (;;) {
+			if (signal.aborted || localController.signal.aborted) throw signalAbortError(signal.aborted ? signal : localController.signal, "interactive execution aborted");
+			status = await current.status({ signal: run.activeLink?.signal });
+			await run.flushChain;
+			if (run.controlError !== void 0) throw controlErrorValue(run.controlError);
+			if (status.state !== "running") break;
+			await sleep(input.pollIntervalMs ?? 100, run.activeLink?.signal);
 		}
+		const finished = status;
+		const output = {
+			provider: input.provider.name,
+			environmentId: current.ref.run.environmentId,
+			sessionId: current.ref.run.sessionId,
+			executionId: current.ref.run.executionId,
+			state: finished?.state === "exited" ? "exited" : "unknown",
+			ref: current.ref,
+			...finished?.state === "exited" && finished.reason ? { reason: finished.reason } : {},
+			...finished?.state === "exited" && finished.exitCode !== void 0 ? { exitCode: finished.exitCode } : {},
+			...finished?.state === "exited" && finished.exitSignal !== void 0 ? { exitSignal: finished.exitSignal } : {}
+		};
+		const spent = {
+			iterations: 1,
+			tokens: {
+				input: 0,
+				output: 0
+			},
+			tokensKnown: false,
+			usd: 0,
+			usdKnown: false,
+			ms: Date.now() - startedAt
+		};
+		run.artifact = {
+			outRef: contentAddress(output),
+			out: output,
+			spent
+		};
+	} finally {
+		run.activeLink?.release();
+	}
+}
+async function flushInbox(run) {
+	run.flushChain = run.flushChain.then(async () => {
+		const handle = run.handle;
+		if (!handle) return;
+		const lease = run.inbox.take();
 		try {
+			const messages = lease.messages;
+			if (messages.length === 0) return;
+			const prompt = run.inbox.fold(messages);
+			const operationId = `interactive-prompt-${canonicalCandidateDigest({
+				ref: handle.ref,
+				prompt
+			}).slice(7)}`;
 			const control = await claimRetainedInteractiveControl({
 				handle,
-				holderId: input.holderId(void 0),
-				signal
+				holderId: run.input.holderId(void 0)
 			});
 			const material = {
 				operationId,
 				ref: handle.ref,
-				control
+				control,
+				prompt
 			};
 			const command = {
 				...material,
-				requestDigest: agentInteractiveSessionStopRequestDigest(material)
+				requestDigest: agentInteractiveSessionPromptRequestDigest(material)
 			};
-			const acknowledgement = await handle.stop(command, signal === void 0 ? void 0 : { signal });
-			localController.abort(reason ?? "interactive cancellation requested");
-			return cancellationFromAcknowledgement(acknowledgement, observedAt);
+			await handle.sendPrompt(command);
+			for (const message of messages) lease.commit(operationId, message.id);
 		} catch (error) {
-			localController.abort(reason ?? "interactive cancellation requested");
-			return {
-				status: "unknown",
-				effect: "cancel_requested",
-				observedAt,
-				detail: error instanceof Error ? error.message : String(error),
-				evidence: { operationId }
-			};
-		}
-	}
-	async function teardownInteractive() {
-		localController.abort("interactive worker teardown");
-		activeLink?.release();
-		await startPromise?.catch(() => void 0);
-		if (handle) {
-			if ((await safeStatus(handle))?.state === "running") {
-				const cancellation = await stopInteractive(`interactive-teardown-${canonicalCandidateDigest(handle.ref).slice(7)}`, "interactive worker teardown");
-				if (cancellation.status === "rejected" || cancellation.status === "unknown") throw new Error(cancellation.detail ?? "interactive teardown was not acknowledged");
-			}
+			lease.release();
+			run.controlError ??= error;
 		}
-		await destroyEnvironment();
-		return { destroyed: true };
+	});
+	await run.flushChain;
+}
+async function stopInteractive(run, operationId, reason, signal) {
+	const observedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const handle = run.handle;
+	if (!handle) {
+		run.localController.abort(reason ?? "interactive cancellation requested");
+		return {
+			status: "unknown",
+			effect: "cancel_requested",
+			observedAt,
+			detail: "interactive process has not published a provider reference"
+		};
 	}
-	async function destroyEnvironment() {
-		if (input.destroyEnvironmentOnTeardown === false) return;
-		if (createdEnvironment !== void 0) {
-			await destroyConfirmed(createdEnvironment);
-			return;
-		}
-		if (!input.provider.get) return;
-		const cleanupEnvironmentId = environmentId ?? handle?.ref.run.environmentId;
-		if (!cleanupEnvironmentId) return;
-		const environment = await input.provider.get(cleanupEnvironmentId);
-		if (environment !== void 0 && environment !== null) await destroyConfirmed(environment);
+	try {
+		const control = await claimRetainedInteractiveControl({
+			handle,
+			holderId: run.input.holderId(void 0),
+			signal
+		});
+		const material = {
+			operationId,
+			ref: handle.ref,
+			control
+		};
+		const command = {
+			...material,
+			requestDigest: agentInteractiveSessionStopRequestDigest(material)
+		};
+		const acknowledgement = await handle.stop(command, signal === void 0 ? void 0 : { signal });
+		run.localController.abort(reason ?? "interactive cancellation requested");
+		return cancellationFromAcknowledgement(acknowledgement, observedAt);
+	} catch (error) {
+		run.localController.abort(reason ?? "interactive cancellation requested");
+		return {
+			status: "unknown",
+			effect: "cancel_requested",
+			observedAt,
+			detail: error instanceof Error ? error.message : String(error),
+			evidence: { operationId }
+		};
 	}
-	async function destroyConfirmed(environment) {
-		try {
-			await destroyInteractiveEnvironment(environment);
-		} catch (error) {
-			if (!await environmentGone(input.provider, environment.id)) throw error;
+}
+async function teardownInteractive(run) {
+	run.localController.abort("interactive worker teardown");
+	run.activeLink?.release();
+	await run.startPromise?.catch(() => void 0);
+	if (run.handle) {
+		if ((await safeStatus(run.handle))?.state === "running") {
+			const cancellation = await stopInteractive(run, `interactive-teardown-${canonicalCandidateDigest(run.handle.ref).slice(7)}`, "interactive worker teardown");
+			if (cancellation.status === "rejected" || cancellation.status === "unknown") throw new Error(cancellation.detail ?? "interactive teardown was not acknowledged");
 		}
 	}
-	return executor;
+	await destroyEnvironment(run);
+	return { destroyed: true };
 }
-function admissionWriter(ctx, provider, workerId) {
-	const candidate = ctx.seams[interactiveAdmissionSeamKey];
-	if (typeof candidate === "function") return async (admission) => {
-		await candidate(admission);
-	};
-	const records = /* @__PURE__ */ new Map();
-	return async (admission) => {
-		const prior = records.get(admission.phase);
-		if (prior && canonicalCandidateDigest(prior) !== canonicalCandidateDigest(admission)) throw new Error(`worker ${workerId ?? "(unscoped)"} provider ${provider} admission changed in memory`);
-		records.set(admission.phase, detachedSnapshot(admission, "interactive admission"));
-	};
-}
-function derivedKey(kind, value) {
-	return `${kind}-${canonicalCandidateDigest(value).slice(7)}`;
+async function destroyEnvironment(run) {
+	const { input } = run;
+	if (input.destroyEnvironmentOnTeardown === false) return;
+	if (run.createdEnvironment !== void 0) {
+		await destroyConfirmed(input.provider, run.createdEnvironment);
+		return;
+	}
+	if (!input.provider.get) return;
+	const cleanupEnvironmentId = run.environmentId ?? run.handle?.ref.run.environmentId;
+	if (!cleanupEnvironmentId) return;
+	const environment = await input.provider.get(cleanupEnvironmentId);
+	if (environment !== void 0 && environment !== null) await destroyConfirmed(input.provider, environment);
 }
-function stableKey(value, label) {
-	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${label} must be a non-empty string`);
-	const key = value.trim();
-	if (key.length > 256) throw new Error(`${label} must not exceed 256 bytes`);
-	return key;
+async function destroyConfirmed(provider, environment) {
+	try {
+		await destroyInteractiveEnvironment(environment);
+	} catch (error) {
+		if (!await environmentGone(provider, environment.id)) throw error;
+	}
 }
 function unavailableReason(error) {
 	const message = error instanceof Error ? error.message : String(error);
@@ -582,6 +496,117 @@ async function safeStatus(handle) {
 	}
 }
 //#endregion
+//#region src/runtime/supervise/interactive-worker.ts
+/**
+* Runtime-owned worker seam for a provider's native interactive coding-agent process. It composes
+* the retained-interactive lifecycle, adding no second stream, replay buffer, session id or
+* cancellation protocol: the provider owns process state; Scope owns the worker, journal, budget
+* and local control inbox.
+*/
+/**
+* Build a `MakeWorkerAgent` that starts one provider-owned native TUI per worker. A Scope supplies
+* the durable admission hook and node attempt; the worker exposes `interactiveReady`, so the exact
+* provider reference is written before another process can attach, and `attachWorker` reconnects
+* it through the provider's public `get`/interactive contract.
+*/
+function workerFromInteractiveProvider(provider, options = {}) {
+	if (!provider.name.trim()) throw new Error("workerFromInteractiveProvider: provider.name required");
+	if (!provider.get) throw new Error(`workerFromInteractiveProvider(${provider.name}): provider.get is required for reconnect`);
+	const capturedEnvironment = options.environment ? structuredClone(options.environment) : void 0;
+	const unscopedNamespace = randomUUID();
+	let unscopedOrdinal = 0;
+	const runtime = options.runtime ?? provider.name;
+	return (rawProfile, spawnContext) => {
+		const profile = executableAgentProfileSnapshot(rawProfile, `workerFromInteractiveProvider(${provider.name})`);
+		const input = {
+			provider: provider.name,
+			profile,
+			...spawnContext === void 0 ? {} : { context: spawnContext }
+		};
+		const assignmentId = spawnContext?.assignmentId ?? `unscoped:${unscopedNamespace}:${unscopedOrdinal++}`;
+		const baseInput = {
+			...input,
+			nodeId: spawnContext?.parentNodeId
+		};
+		const environmentKey = stableKey(options.environmentIdempotencyKey?.({ ...baseInput }) ?? derivedKey("supervised-interactive-environment", {
+			provider: provider.name,
+			assignmentId,
+			parentNodeId: spawnContext?.parentNodeId,
+			profile
+		}), "environment idempotency key");
+		const name = profile.name ?? "interactive-worker";
+		const executorFactory = (spec, ctx) => interactiveExecutor({
+			provider,
+			profile: spec.profile,
+			context: spawnContext,
+			environment: capturedEnvironment,
+			environmentKey,
+			interactiveKey: (task) => stableKey(options.interactiveIdempotencyKey?.({
+				...baseInput,
+				task
+			}) ?? derivedKey("supervised-interactive-session", {
+				provider: provider.name,
+				assignmentId,
+				parentNodeId: spawnContext?.parentNodeId,
+				profile: spec.profile,
+				task
+			}), "interactive idempotency key"),
+			holderId: (task) => {
+				return stableKey((typeof options.holderId === "function" ? options.holderId({
+					...baseInput,
+					task
+				}) : options.holderId) ?? `runtime-interactive-worker:${canonicalCandidateDigest({
+					provider: provider.name,
+					assignmentId
+				})}`, "interactive holder id");
+			},
+			initialPrompt: options.initialPrompt,
+			cwd: options.cwd,
+			cols: options.cols,
+			rows: options.rows,
+			runtime,
+			pollIntervalMs: options.pollIntervalMs,
+			destroyEnvironmentOnTeardown: options.destroyEnvironmentOnTeardown,
+			executionAttemptId: ctx.node?.attemptId,
+			nodeId: ctx.node?.nodeId,
+			admission: admissionWriter(ctx, provider.name, ctx.node?.nodeId)
+		});
+		return {
+			name,
+			act: async () => {
+				throw new Error("workerFromInteractiveProvider: interactive workers execute through executorSpec");
+			},
+			executorSpec: {
+				profile,
+				harness: null,
+				executorFactory,
+				...spawnContext?.execution ? { execution: spawnContext.execution } : {}
+			}
+		};
+	};
+}
+function admissionWriter(ctx, provider, workerId) {
+	const candidate = ctx.seams[interactiveAdmissionSeamKey];
+	if (typeof candidate === "function") return async (admission) => {
+		await candidate(admission);
+	};
+	const records = /* @__PURE__ */ new Map();
+	return async (admission) => {
+		const prior = records.get(admission.phase);
+		if (prior && canonicalCandidateDigest(prior) !== canonicalCandidateDigest(admission)) throw new Error(`worker ${workerId ?? "(unscoped)"} provider ${provider} admission changed in memory`);
+		records.set(admission.phase, detachedSnapshot(admission, "interactive admission"));
+	};
+}
+function derivedKey(kind, value) {
+	return `${kind}-${canonicalCandidateDigest(value).slice(7)}`;
+}
+function stableKey(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${label} must be a non-empty string`);
+	const key = value.trim();
+	if (key.length > 256) throw new Error(`${label} must not exceed 256 bytes`);
+	return key;
+}
+//#endregion
 //#region src/runtime/supervise/provision-supervisor.ts
 /**
 * Public one-call composition for a durable Runtime supervisor proof run.
@@ -1002,4 +1027,4 @@ function writeState(path, state) {
 //#endregion
 export { workerFromInteractiveProvider as n, claimRetainedInteractiveControl as r, provisionSupervisor as t };
 
-//# sourceMappingURL=provision-supervisor-DqvWXmAE.js.map
+//# sourceMappingURL=provision-supervisor-DL6gEMQp.js.map