@tangle-network/agent-runtime 0.109.2 → 0.111.0

package/dist/{supervise-DyPmmhJ6.js → supervise-CeZtA1wu.js}

@@ -1,10 +1,10 @@
 import { c as RuntimeRunStateError, i as ConfigError, o as NotFoundError, t as AgentEvalError$1, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { a as randomSuffix, c as stringifySafe, d as withTimeout, f as zeroTokenUsage, i as mapWithConcurrency, l as throwAbort, n as deleteBoxSafe, o as randomUuid, s as sleep, t as addTokenUsage, u as throwIfAborted } from "./util-MVgdwuIS.js";
-import { a as contentAddress, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore } from "./spawn-journal-CwPvKUTa.js";
-import { A as createWorktree, C as routerChatWithUsage, D as runWorktreeChecks, O as runWorktreeHarness, T as runBrainLoop, a as runFinalizer, i as pickBestDelivered, j as removeWorktree, k as captureWorktreeDiff, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-sTJC9psT.js";
+import { a as mapWithConcurrency, c as sleep, d as throwIfAborted, f as withTimeout, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage, r as deleteBoxSafe, s as randomUuid, t as abortError, u as throwAbort } from "./util-Cc9g9Y-o.js";
+import { a as contentAddress, i as InMemorySpawnJournal, n as FileSpawnJournal, r as InMemoryResultBlobStore, t as FileResultBlobStore } from "./spawn-journal-DLhnom3e.js";
+import { A as createWorktree, C as routerChatWithUsage, D as runWorktreeChecks, O as runWorktreeHarness, T as runBrainLoop, a as runFinalizer, i as pickBestDelivered, j as removeWorktree, k as captureWorktreeDiff, l as withDriverExecutor, n as bestDelivered, o as runTree, t as createSupervisor, x as routerBrain, y as createActivityLog } from "./supervisor-ByCPHcp9.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, n as extractLlmCallEvent } from "./sandbox-events-DeI5xX8P.js";
-import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor } from "./environment-provider-CfLUmKmf.js";
+import { i as resolveAgentEnvironmentProvider, n as providerAsExecutor, s as buildBackendOptions } from "./environment-provider-BsHpW4Dp.js";
 import { r as buildLoopSpanNodes } from "./otel-export-D34IQW1C.js";
 import { t as createStdioToolServer } from "./tool-server-RcWgLIsL.js";
 import { n as UI_LENSES } from "./substrate-B0TYNrXn.js";
@@ -263,37 +263,6 @@ function isRetryable(err) {
 	return /provision failed|edge data plane|not reachable|failed to create sandbox/i.test(msg);
 }
 //#endregion
-//#region src/runtime/sandbox-backend.ts
-/**
-* Resolve the backend `type`: an explicit override wins, then the profile's
-* `metadata.backendType` hint, else the SDK's profile-driven default
-* (`'opencode'` on the platform side). A profile with no hint falls through to
-* the default rather than asserting provenance the profile never declared.
-*/
-function resolveBackendType(profile, override) {
-	if (override?.type) return override.type;
-	const explicit = profile.metadata?.backendType;
-	if (typeof explicit === "string") return explicit;
-	return "opencode";
-}
-/**
-* Build `CreateSandboxOptions` for `profile`, merging `overrides` and setting
-* `backend.profile`. `model`/`server` from an override backend pass through.
-*/
-function buildBackendOptions(profile, overrides) {
-	const base = overrides ?? {};
-	const overrideBackend = base.backend;
-	return {
-		...base,
-		backend: {
-			type: resolveBackendType(profile, overrideBackend),
-			profile,
-			...overrideBackend?.model ? { model: overrideBackend.model } : {},
-			...overrideBackend?.server ? { server: overrideBackend.server } : {}
-		}
-	};
-}
-//#endregion
 //#region src/runtime/sandbox-capabilities.ts
 const probeCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -1317,7 +1286,9 @@ function toToolSpan(input, runId, seq, at) {
 		name: input.toolName,
 		toolName: input.toolName,
 		args: input.args,
+		...input.argsCaptured === false ? { argsCaptured: false } : {},
 		status: input.status ?? "ok",
+		...input.error !== void 0 ? { error: input.error } : {},
 		startedAt,
 		endedAt,
 		...input.result !== void 0 ? { result: input.result } : {}
@@ -1517,13 +1488,13 @@ function sandboxSessionTraceSource(box, sessionId, opts = {}) {
 * already maintains. So this module is a thin protocol adapter, and every capability maps onto a
 * verb pi already has:
 *
-*   `execute`        → `prompt`, draining pi's event stream until `agent_end`
+*   `execute`        → `prompt`, draining pi's event stream until `agent_settled`
 *   `deliver`        → `prompt` with `streamingBehavior` — pi owns the queue, we do not
 *   `teardown`       → `abort`, then close stdin and reap the process
 *   `progress`       → pi's `tool_execution_start`/`_end` + `turn_end` events, plus `get_state`'s
 *                      `pendingMessageCount` mirrored locally so the read stays synchronous
 *   `traceSource`    → the same tool events decoded into the shared `ToolSpan` currency
-*   `resultArtifact` → the last assistant text collected off the stream
+*   `resultArtifact` → the terminal successful assistant turn
 *
 * It is registered through the DOCUMENTED extension point (`ExecutorRegistry.register('pi', …)`),
 * so nothing in the resolver switches on it and a consumer can replace it wholesale.
@@ -1532,9 +1503,11 @@ function sandboxSessionTraceSource(box, sessionId, opts = {}) {
 * are read structurally off JSON lines, so a pi that adds commands stays compatible and a pi that
 * is not installed simply fails loud at spawn instead of at import.
 *
-* Usage accounting: pi reports token usage on its assistant messages when the provider supplies
-* it. Nothing is fabricated — a turn whose usage pi does not report contributes an `iteration`
-* event and zero tokens, exactly like the other honest executors.
+* Usage accounting: pi repeats the same assistant receipt in `message_end` and `turn_end`.
+* Only `turn_end` is counted, once per model call. Pi reports cache traffic separately from fresh
+* input, so all three input classes are folded into Runtime's two-field token total. Subscription
+* usage whose dollar price is absent or zero stays explicitly unknown through the live usage
+* stream and terminal artifact.
 *
 * @experimental
 */
@@ -1598,10 +1571,10 @@ const piExecutor = (spec, ctx) => {
 	};
 };
 /**
-* One pi RPC session, run to `agent_end`. Every steer delivered while the turn is in flight is
+* One pi RPC session, run to `agent_settled`. Every steer delivered while the turn is in flight is
 * forwarded to pi IMMEDIATELY (pi queues and delivers it at its own turn boundary — the queue we
-* deliberately do not reimplement), and any steer still unread when pi goes idle re-prompts it,
-* so a pi worker cannot settle while a message it never saw is pending.
+* deliberately do not reimplement), and any steer still unread when pi settles re-prompts it.
+* `agent_end` is deliberately not terminal: Pi may auto-retry or compact after emitting it.
 */
 async function* streamPiSession(args) {
 	const { seam, inbox, activity, state } = args;
@@ -1611,12 +1584,23 @@ async function* streamPiSession(args) {
 		output: 0
 	};
 	let usd = 0;
+	let usdKnown = true;
+	throwIfAborted(args.signal);
+	throwIfAborted(args.controller.signal);
 	const proc = spawnPi(seam);
 	state.proc = proc;
 	state.note = "connected";
 	const events = [];
-	let idle = false;
+	const pendingTools = /* @__PURE__ */ new Map();
+	const awaitingPromptResponses = /* @__PURE__ */ new Set();
+	let settled = false;
+	let acceptedPromptSinceSettlement = false;
+	let promptSequence = 0;
+	let lastAssistant;
 	let failure;
+	let abortDeadline;
+	let exited = false;
+	let exitCode;
 	let wake;
 	const notify = () => {
 		const w = wake;
@@ -1625,59 +1609,80 @@ async function* streamPiSession(args) {
 	};
 	const stdoutLines = readJsonLines(proc, (value) => {
 		const ev = value;
-		if (ev.type === "agent_start") idle = false;
-		if (ev.type === "agent_end") idle = true;
 		events.push(ev);
 		notify();
 	});
 	proc.once("exit", (code) => {
-		if (!idle && code !== 0 && code !== null) failure = new ValidationError(`piExecutor: pi exited with code ${code}`);
-		idle = true;
+		exited = true;
+		exitCode = code;
 		notify();
 	});
 	proc.once("error", (e) => {
 		failure = new ValidationError(`piExecutor: pi failed to start: ${e.message}`);
-		idle = true;
 		notify();
 	});
 	const abortAll = () => {
+		if (abortDeadline !== void 0) return;
 		sendCommand(proc, { type: "abort" });
-		idle = true;
+		abortDeadline = Date.now() + PI_ABORT_RECEIPT_MS;
+		state.note = "aborting";
 		notify();
 	};
-	if (args.signal.aborted || args.controller.signal.aborted) abortAll();
-	else {
-		args.signal.addEventListener("abort", abortAll, { once: true });
-		args.controller.signal.addEventListener("abort", abortAll, { once: true });
-	}
+	args.signal.addEventListener("abort", abortAll, { once: true });
+	args.controller.signal.addEventListener("abort", abortAll, { once: true });
 	const system = args.spec.profile.prompt?.systemPrompt;
 	const opening = system ? `${system}\n\n${taskText(args.task)}` : taskText(args.task);
 	const deadline = seam.turnTimeoutMs ? Date.now() + seam.turnTimeoutMs : void 0;
-	try {
+	const sendPrompt = (message, streamingBehavior) => {
+		const id = `agent-runtime-prompt-${++promptSequence}`;
+		awaitingPromptResponses.add(id);
 		sendCommand(proc, {
+			id,
 			type: "prompt",
-			message: opening
+			message,
+			...streamingBehavior ? { streamingBehavior } : {}
 		});
+	};
+	try {
+		if (args.signal.aborted || args.controller.signal.aborted) throw abortError();
+		sendPrompt(opening);
 		state.note = "turn 0";
 		for (;;) {
-			if (!idle) forwardPending(proc, inbox, activity);
+			if (!settled && abortDeadline === void 0) forwardPending(inbox, activity, sendPrompt);
 			while (events.length > 0) {
 				const ev = events.shift();
-				for (const usage of projectPiEvent(ev, args, tokens)) {
-					if (usage.kind === "cost") usd += usage.usd;
+				if (ev.type === "response" && ev.command === "prompt" && typeof ev.id === "string" && awaitingPromptResponses.delete(ev.id)) if (ev.success === true) acceptedPromptSinceSettlement = true;
+				else failure = new ValidationError(`piExecutor: Pi rejected prompt: ${ev.error ?? "unknown RPC error"}`);
+				if (ev.type === "agent_start") settled = false;
+				if (ev.type === "agent_settled") {
+					settled = true;
+					acceptedPromptSinceSettlement = false;
+				}
+				const projected = projectPiEvent(ev, args, tokens, pendingTools);
+				if (projected.assistant) lastAssistant = projected.assistant;
+				for (const usage of projected.events) {
+					if (usage.kind === "cost") {
+						usd += usage.usd;
+						if (usage.usdKnown === false) usdKnown = false;
+					}
 					yield usage;
 				}
 			}
 			if (failure) throw failure;
-			if (deadline !== void 0 && Date.now() > deadline) throw new ValidationError("piExecutor: turn exceeded turnTimeoutMs");
-			if (idle) {
+			if (abortDeadline !== void 0 && (settled || exited)) throw abortError();
+			if (abortDeadline === void 0 && exited && (!settled || awaitingPromptResponses.size > 0 || acceptedPromptSinceSettlement)) throw new ValidationError(`piExecutor: pi exited before agent_settled (code ${exitCode ?? "unknown"})`);
+			if (abortDeadline === void 0 && deadline !== void 0 && Date.now() > deadline) throw new ValidationError("piExecutor: turn exceeded turnTimeoutMs");
+			if (abortDeadline !== void 0 && Date.now() > abortDeadline) {
+				const error = abortError();
+				error.message = `piExecutor: abort did not settle within ${PI_ABORT_RECEIPT_MS}ms`;
+				throw error;
+			}
+			if (settled && awaitingPromptResponses.size === 0 && !acceptedPromptSinceSettlement) {
 				const pending = inbox.drain();
 				if (pending.length === 0) break;
-				idle = false;
-				sendCommand(proc, {
-					type: "prompt",
-					message: inbox.fold(pending)
-				});
+				settled = false;
+				lastAssistant = void 0;
+				sendPrompt(inbox.fold(pending));
 				state.note = `turn ${state.turns}`;
 				continue;
 			}
@@ -1699,10 +1704,16 @@ async function* streamPiSession(args) {
 		args.controller.signal.removeEventListener("abort", abortAll);
 		await killPi(proc, 2e3).catch(() => ({ destroyed: false }));
 	}
+	if (args.signal.aborted || args.controller.signal.aborted) throw abortError();
+	if (!lastAssistant) throw new ValidationError("piExecutor: agent_settled without an assistant turn");
+	if (lastAssistant.stopReason === "aborted") throw abortError();
+	if (lastAssistant.stopReason === "error") throw new ValidationError(`piExecutor: Pi assistant failed: ${lastAssistant.errorMessage ?? "unknown provider error"}`);
+	state.lastText = lastAssistant.text;
 	const spent = {
 		iterations: state.turns,
 		tokens,
 		usd,
+		...usdKnown ? {} : { usdKnown: false },
 		ms: Date.now() - started
 	};
 	state.artifact = {
@@ -1715,14 +1726,10 @@ async function* streamPiSession(args) {
 	};
 }
 /** Route messages through pi's state-safe prompt command; pi owns the queue and idle transition. */
-function forwardPending(proc, inbox, activity) {
+function forwardPending(inbox, activity, sendPrompt) {
 	const pending = inbox.drain();
 	for (const m of pending) {
-		sendCommand(proc, {
-			type: "prompt",
-			message: renderOne(m),
-			streamingBehavior: m.interrupt ? "steer" : "followUp"
-		});
+		sendPrompt(renderOne(m), m.interrupt ? "steer" : "followUp");
 		activity.push({
 			at: Date.now(),
 			kind: "note",
@@ -1737,7 +1744,7 @@ function renderOne(m) {
 }
 /** Project one pi event onto usage events, updating turn count / activity / trace as a side
 *  effect. pi's tool events are the live trace; its `turn_end` bumps the turn counter. */
-function projectPiEvent(ev, args, tokens) {
+function projectPiEvent(ev, args, tokens, pendingTools) {
 	const out = [];
 	const at = Date.now();
 	if (ev.type === "tool_execution_start" && typeof ev.toolName === "string") {
@@ -1747,10 +1754,18 @@ function projectPiEvent(ev, args, tokens) {
 			label: ev.toolName,
 			detail: describeArgs$1(ev.args)
 		});
-		return out;
+		if (typeof ev.toolCallId === "string") pendingTools.set(ev.toolCallId, {
+			args: ev.args ?? {},
+			startedAt: at
+		});
+		return { events: out };
 	}
 	if (ev.type === "tool_execution_end" && typeof ev.toolName === "string") {
 		const status = ev.isError === true ? "error" : "ok";
+		const callId = typeof ev.toolCallId === "string" ? ev.toolCallId : void 0;
+		const started = callId ? pendingTools.get(callId) : void 0;
+		if (callId) pendingTools.delete(callId);
+		const error = status === "error" ? describeToolError(ev.result) : void 0;
 		args.activity.push({
 			at,
 			kind: "tool",
@@ -1759,13 +1774,19 @@ function projectPiEvent(ev, args, tokens) {
 		});
 		args.record({
 			toolName: ev.toolName,
-			args: ev.args ?? {},
+			args: started?.args ?? {},
+			...started ? {} : { argsCaptured: false },
 			status,
-			...typeof ev.toolCallId === "string" ? { callId: ev.toolCallId } : {}
+			...ev.result !== void 0 ? { result: ev.result } : {},
+			...error !== void 0 ? { error } : {},
+			...callId ? { callId } : {},
+			...started ? { startedAt: started.startedAt } : {},
+			endedAt: at
 		});
-		return out;
+		return { events: out };
 	}
-	if (ev.type === "turn_end" || ev.type === "message_end") {
+	if (ev.type === "message_end") return { events: out };
+	if (ev.type === "turn_end") {
 		const usage = readUsage(ev.message);
 		if (usage && (usage.input || usage.output)) {
 			tokens.input += usage.input;
@@ -1776,38 +1797,55 @@ function projectPiEvent(ev, args, tokens) {
 				output: usage.output
 			});
 		}
-		if (usage?.usd) out.push({
+		out.push(usage?.usd !== void 0 ? {
 			kind: "cost",
 			usd: usage.usd
+		} : {
+			kind: "cost",
+			usd: 0,
+			usdKnown: false
 		});
-		const text = readText(ev.message);
-		if (text) args.state.lastText = text;
-		if (ev.type === "turn_end") {
-			args.state.turns += 1;
-			args.activity.push({
-				at,
-				kind: "turn",
-				label: `turn ${args.state.turns}`
-			});
-			out.push({ kind: "iteration" });
-		}
+		args.state.turns += 1;
+		args.activity.push({
+			at,
+			kind: "turn",
+			label: `turn ${args.state.turns}`
+		});
+		out.push({ kind: "iteration" });
+		const assistant = readAssistantOutcome(ev.message);
+		return {
+			events: out,
+			...assistant ? { assistant } : {}
+		};
 	}
-	return out;
+	return { events: out };
 }
-/** pi's assistant message carries provider usage when the provider reported it. Absent, nothing
-*  is fabricated — the turn still counts as an iteration with zero tokens. */
+/** Pi's fresh input excludes cache reads and writes. Runtime's input channel includes all model
+* input, so combine them once at the assistant receipt. A missing or zero price is unknown because
+* subscription-backed providers report zero even when compute was not free. */
 function readUsage(message) {
 	if (!message || typeof message !== "object") return void 0;
 	const usage = message.usage;
 	if (!usage || typeof usage !== "object") return void 0;
 	const u = usage;
-	const input = num(u.input) ?? num(u.inputTokens) ?? num(u.prompt_tokens) ?? 0;
+	const input = num(u.prompt_tokens) ?? (num(u.input) ?? num(u.inputTokens) ?? 0) + (num(u.cacheRead) ?? num(u.cache_read_input_tokens) ?? num(u.cacheReadInputTokens) ?? 0) + (num(u.cacheWrite) ?? num(u.cache_creation_input_tokens) ?? num(u.cacheCreationInputTokens) ?? 0);
 	const output = num(u.output) ?? num(u.outputTokens) ?? num(u.completion_tokens) ?? 0;
 	const costRaw = u.cost;
+	const reportedUsd = num(costRaw) ?? (costRaw && typeof costRaw === "object" ? num(costRaw.total) ?? num(costRaw.totalCost) : void 0);
 	return {
 		input,
 		output,
-		usd: num(costRaw) ?? (costRaw && typeof costRaw === "object" ? num(costRaw.totalCost) ?? 0 : 0)
+		...reportedUsd !== void 0 && reportedUsd > 0 ? { usd: reportedUsd } : {}
+	};
+}
+function readAssistantOutcome(message) {
+	if (!message || typeof message !== "object") return void 0;
+	const value = message;
+	if (value.role !== "assistant") return void 0;
+	return {
+		text: readText(message) ?? "",
+		...typeof value.stopReason === "string" ? { stopReason: value.stopReason } : {},
+		...typeof value.errorMessage === "string" ? { errorMessage: value.errorMessage } : {}
 	};
 }
 function readText(message) {
@@ -1819,7 +1857,7 @@ function readText(message) {
 	return text.length > 0 ? text : void 0;
 }
 function num(v) {
-	return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+	return typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : void 0;
 }
 function describeArgs$1(argsValue) {
 	if (!argsValue || typeof argsValue !== "object") return void 0;
@@ -1837,6 +1875,18 @@ function describeArgs$1(argsValue) {
 		if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
 	}
 }
+function describeToolError(result) {
+	if (typeof result === "string" && result.length > 0) return result;
+	if (result && typeof result === "object") {
+		const value = result;
+		const direct = value.error ?? value.message;
+		if (typeof direct === "string" && direct.length > 0) return direct;
+		if (Array.isArray(value.content)) {
+			const text = value.content.map((block) => block && typeof block === "object" && typeof block.text === "string" ? block.text : "").filter(Boolean).join("\n");
+			if (text.length > 0) return text;
+		}
+	}
+}
 function taskText(task) {
 	if (typeof task === "string") return task;
 	try {
@@ -1901,6 +1951,8 @@ function readJsonLines(proc, onValue) {
 *  Without it the SIGTERM races the command down the pipe and pi never sees the abort at all —
 *  which defeats the reason to wrap pi rather than kill it (a clean abort finalizes its session). */
 const PI_ABORT_GRACE_MS = 500;
+/** Maximum wait for Pi's aborted receipt and `agent_settled` before forced teardown. */
+const PI_ABORT_RECEIPT_MS = 2e3;
 async function killPi(proc, grace) {
 	if (proc.exitCode !== null || proc.killed) return { destroyed: true };
 	if (grace === "brutalKill") {
@@ -3920,6 +3972,7 @@ const coordinationVerbNames = [
 	"list_questions",
 	"answer_question",
 	"ask_parent",
+	"submit_result",
 	"stop",
 	"list_analysts",
 	"run_analyst"
@@ -3930,8 +3983,10 @@ const idArg = {
 };
 /** Build the driver's MCP tools over a live scope. */
 function createCoordinationTools(opts) {
+	const deliverable = opts.deliverable;
 	let stopped = false;
 	let reason;
+	let submitted;
 	let questionSeq = 0;
 	const ledger = [];
 	const questions = [...opts.priorQuestions ?? []];
@@ -4572,6 +4627,53 @@ function createCoordinationTools(opts) {
 				})) };
 			}
 		},
+		...deliverable ? [{
+			name: "submit_result",
+			description: [
+				"Submit the complete result to the injected independent check.",
+				"The first passing result is retained; stop work when accepted.",
+				...deliverable.describe ? [`Expected result: ${deliverable.describe}`] : []
+			].join(" "),
+			inputSchema: {
+				type: "object",
+				properties: { result: { description: "The complete result in the form requested by the task." } },
+				required: ["result"],
+				additionalProperties: false
+			},
+			handler: async (raw) => {
+				if (submitted) return {
+					accepted: true,
+					retained: "earlier-passing-result",
+					stop: true
+				};
+				const a = obj(raw);
+				if (!Object.hasOwn(a, "result")) throw new Error("submit_result: \"result\" is required");
+				const result = structuredClone(a.result);
+				let accepted = false;
+				try {
+					accepted = await deliverable.check(result) === true;
+				} catch {
+					accepted = false;
+				}
+				if (!accepted) return {
+					accepted: false,
+					stop: false
+				};
+				if (submitted) return {
+					accepted: true,
+					retained: "earlier-passing-result",
+					stop: true
+				};
+				submitted = Object.freeze({ result });
+				stopped = true;
+				reason = "result-accepted";
+				return {
+					accepted: true,
+					retained: "this-result",
+					stop: true
+				};
+			}
+		}] : [],
 		{
 			name: "stop",
 			description: "Declare the run complete.",
@@ -4641,6 +4743,7 @@ function createCoordinationTools(opts) {
 		stats: () => bus.stats(),
 		isStopped: () => stopped,
 		stopReason: () => reason,
+		submittedResult: () => submitted,
 		settled: () => ledger,
 		questions: () => questions,
 		drainResolved
@@ -5113,6 +5216,7 @@ function driverAgent(opts) {
 				blobs: opts.blobs,
 				makeWorkerAgent: opts.makeWorkerAgent,
 				perWorker: opts.perWorker,
+				...opts.deliverable ? { deliverable: opts.deliverable } : {},
 				...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
 				...opts.analysts ? { analysts: opts.analysts } : {},
 				...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
@@ -5234,6 +5338,8 @@ function driverAgent(opts) {
 				} }
 			});
 			await coord.drainResolved();
+			const submitted = coord.submittedResult();
+			if (submitted) return submitted.result;
 			return runFinalizer(opts.finalizer ?? bestDelivered, {
 				settled: coord.settled(),
 				blobs: opts.blobs,
@@ -7242,6 +7348,7 @@ async function serveCoordinationMcp(opts) {
 		blobs: opts.blobs,
 		makeWorkerAgent: opts.makeWorkerAgent,
 		perWorker: opts.perWorker,
+		...opts.deliverable ? { deliverable: opts.deliverable } : {},
 		...opts.maxLiveWorkers !== void 0 ? { maxLiveWorkers: opts.maxLiveWorkers } : {},
 		awaitTimeoutMs: opts.awaitTimeoutMs ?? 15e3,
 		...opts.analysts ? { analysts: opts.analysts } : {},
@@ -7303,6 +7410,7 @@ async function serveCoordinationMcp(opts) {
 		url: `http://${host}:${port}/mcp`,
 		port,
 		settled: () => coord.settled(),
+		submittedResult: () => coord.submittedResult(),
 		drainResolved: () => coord.drainResolved(),
 		isStopped: () => coord.isStopped(),
 		history: () => coord.history(),
@@ -7327,9 +7435,8 @@ async function serveCoordinationMcp(opts) {
 *    coordination verbs: `serveCoordinationMcp` exposes spawn/await/steer/stop over the live scope,
 *    and the caller's `driveHarness` runs the harness with that MCP mounted. The harness IS the brain.
 *
-* Both arms spawn children through the SAME `makeWorkerAgent` seam and finalize through the SAME
-* seam (`runFinalizer` over DELIVERED children only — default keep-best, never the driver's own
-* prose).
+* Both arms spawn children through the SAME `makeWorkerAgent` seam and apply the SAME independent
+* deliverable check to direct submissions. Raw driver prose is never eligible.
 */
 /** The standing strategy a router-brained supervisor runs with when its profile names no
 *  `systemPrompt`. The brain's competence IS this prompt: without it the brain has the coordination
@@ -7365,6 +7472,7 @@ function supervisorAgent(profile, deps) {
 		makeWorkerAgent: deps.makeWorkerAgent,
 		perWorker: deps.perWorker,
 		systemPrompt,
+		...deps.deliverable ? { deliverable: deps.deliverable } : {},
 		...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
 		...deps.extraTools ? { extraTools: deps.extraTools } : {},
 		...deps.executeExtraTool ? { executeExtraTool: deps.executeExtraTool } : {},
@@ -7390,6 +7498,7 @@ function supervisorAgent(profile, deps) {
 				blobs: deps.blobs,
 				makeWorkerAgent: deps.makeWorkerAgent,
 				perWorker: deps.perWorker,
+				...deps.deliverable ? { deliverable: deps.deliverable } : {},
 				...deps.maxLiveWorkers !== void 0 ? { maxLiveWorkers: deps.maxLiveWorkers } : {},
 				...deps.analysts ? { analysts: deps.analysts } : {},
 				...deps.analyzeOnSettle ? { analyzeOnSettle: deps.analyzeOnSettle } : {},
@@ -7399,13 +7508,19 @@ function supervisorAgent(profile, deps) {
 				...deps.priorCoordination?.questions.length ? { priorQuestions: deps.priorCoordination.questions } : {}
 			});
 			try {
-				await driveHarness({
-					profile,
-					task,
-					scope,
-					coordinationMcpUrl: mcp.url
-				});
+				try {
+					await driveHarness({
+						profile,
+						task,
+						scope,
+						coordinationMcpUrl: mcp.url
+					});
+				} catch (error) {
+					if (!mcp.submittedResult()) throw error;
+				}
 				await mcp.drainResolved();
+				const submitted = mcp.submittedResult();
+				if (submitted) return submitted.result;
 				return await runFinalizer(deps.finalizer ?? bestDelivered, {
 					settled: mcp.settled(),
 					blobs: deps.blobs,
@@ -7485,6 +7600,7 @@ function supervise(profile, task, opts) {
 			blobs,
 			makeWorkerAgent: workerFactory,
 			perWorker,
+			...opts.deliverable ? { deliverable: opts.deliverable } : {},
 			...log ? { onEvent: (ev) => log.append(runId, ev, new Date(now()).toISOString()) } : {},
 			...priorCoordination && (priorCoordination.questions.length > 0 || priorCoordination.findings.length > 0) ? { priorCoordination } : {},
 			...opts.finalizer ? { finalizer: opts.finalizer } : {},
@@ -7520,4 +7636,4 @@ function supervise(profile, task, opts) {
 //#endregion
 export { eventToSnapshot as $, createDelegateHandler as A, createSteerableSandboxSession as At, DelegationTaskQueue as B, runAgentRounds as Bt, DELEGATE_FEEDBACK_INPUT_SCHEMA as C, createFileRunContext as Ct, DELEGATE_DESCRIPTION as D, createExecutorRegistry as Dt, validateDelegateFeedbackArgs as E, createExecutor as Et, assessAuthoredProfile as F, decodeToolPart as Ft, capDelegationTrace as G, FileCoordinationLog as Gt, DELEGATION_TRACE_MAX_BYTES as H, createSandboxLineage as Ht, authoredWorker as I, sandboxSessionTraceSource as It, DelegationPersistenceError as J, composeLoopTraceEmitters as K, assertModelAllowed as Kt, defaultProfileRichnessThresholds as L, createInbox as Lt, defaultDelegateBudget as M, piExecutor as Mt, delegate as N, piSeamKey as Nt, DELEGATE_INPUT_SCHEMA as O, createWorktreeCliExecutor as Ot, asAuthoredProfile as P, createPushTraceSource as Pt, InMemoryFeedbackStore as Q, profileRichnessFinding as R, createSandboxForSpec as Rt, DELEGATE_FEEDBACK_DESCRIPTION as S, watchTrace as St, createDelegateFeedbackHandler as T, cliWorktreeExecutor as Tt, DELEGATION_TRACE_MAX_SPANS as U, probeSandboxCapabilities as Ut, hashIdempotencyInput as V, runLoop as Vt, buildDelegationTraceSpans as W, acquireSandbox as Wt, FileDelegationStore as X, DelegationStateCorruptError as Y, InMemoryDelegationStore as Z, DELEGATE_UI_AUDIT_DESCRIPTION as _, effectiveConcurrency as _t, createInProcessTransport as a, createProgressTracker as at, createDelegateUiAuditHandler as b, rollingDispatch as bt, DELEGATION_STATUS_INPUT_SCHEMA as c, sampleFromSettled as ct, validateDelegationStatusArgs as d, bestSoFar as dt, driverAgent as et, DELEGATION_HISTORY_DESCRIPTION as f, plateauLength as ft, validateDelegationHistoryArgs as g, createEventBus as gt, createDelegationHistoryHandler as h, createCoordinationTools as ht, serveCoordinationMcp as i, anyOf as it, validateDelegateArgs as j, PI_RUNTIME as jt, DELEGATE_TOOL_NAME as k, DEFAULT_SANDBOX_STEERING_MAX_TURNS as kt, DELEGATION_STATUS_TOOL_NAME as l, anytimeReport as lt, DELEGATION_HISTORY_TOOL_NAME as m, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as mt, workerFromBackend as n, allOf as nt, createMcpServer as o, noProgressFor as ot, DELEGATION_HISTORY_INPUT_SCHEMA as p, renderAnytimeTable as pt, createDelegationTraceCollector as q, gateOnDeliverable as qt, supervisorAgent as r, allWorkersStalled as rt, DELEGATION_STATUS_DESCRIPTION as s, plateau as st, supervise as t, finalizeBestDelivered as tt, createDelegationStatusHandler as u, areaUnderCurve as ut, DELEGATE_UI_AUDIT_INPUT_SCHEMA as v, freeSlots as vt, DELEGATE_FEEDBACK_TOOL_NAME as w, createInMemoryRunContext as wt, validateDelegateUiAuditArgs as x, defaultToolDetectors as xt, DELEGATE_UI_AUDIT_TOOL_NAME as y, queueOf as yt, supervisorInstructions as z, defaultSelectWinner as zt };
 
-//# sourceMappingURL=supervise-DyPmmhJ6.js.map
+//# sourceMappingURL=supervise-CeZtA1wu.js.map