@tangle-network/agent-runtime 0.266.0 → 0.273.3

package/dist/{supervisor-B8UMAXya.js → supervisor-DdKPGluv.js}

@@ -14,7 +14,8 @@ import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, readdir, realp
 import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
 import { homedir, hostname, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
-import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
+import { ATTR, deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
+import { REDACTION_VERSION as REDACTION_VERSION$1, redact } from "@tangle-network/agent-eval/traces";
 import { SDKError, generateIdempotencyKey, withRetry } from "@tangle-network/agent-core";
 import { collectAgentFinalMessageText, collectAgentResponseText } from "@tangle-network/sandbox";
 import { request } from "node:http";
@@ -4797,7 +4798,7 @@ function sanitizeAgentRuntimeEvent(event, options = {}) {
 	if (event.type === "questions_end") return {
 		...base,
 		questions: event.questions.map((question) => sanitizeQuestion(question, options)),
-		userAnswers: options.includeUserAnswers ? event.userAnswers : redactRecord(event.userAnswers)
+		userAnswers: options.includeUserAnswers ? included(event.userAnswers) : redactRecord(event.userAnswers)
 	};
 	if (event.type === "acquisition_start") return {
 		...base,
@@ -4845,7 +4846,7 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 		...withTask,
 		timestamp: event.timestamp,
 		questions: event.questions.map((question) => sanitizeQuestion(question, options)),
-		userAnswers: options.includeUserAnswers ? event.userAnswers : redactRecord(event.userAnswers)
+		userAnswers: options.includeUserAnswers ? included(event.userAnswers) : redactRecord(event.userAnswers)
 	};
 	if (event.type === "acquisition_start") return {
 		type: event.type,
@@ -4868,7 +4869,7 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 		timestamp: event.timestamp,
 		toolName: event.toolName,
 		toolCallId: event.toolCallId,
-		args: options.includeControlPayloads ? event.args : void 0
+		args: options.includeControlPayloads ? included(event.args) : void 0
 	};
 	if (event.type === "tool_result") return {
 		type: event.type,
@@ -4877,7 +4878,7 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 		timestamp: event.timestamp,
 		toolName: event.toolName,
 		toolCallId: event.toolCallId,
-		result: options.includeControlPayloads ? event.result : void 0
+		result: options.includeControlPayloads ? included(event.result) : void 0
 	};
 	if (event.type === "llm_call") return {
 		type: event.type,
@@ -4900,8 +4901,8 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 		name: event.name,
 		mimeType: event.mimeType,
 		uri: options.includeEvidenceIds ? event.uri : void 0,
-		content: options.includeControlPayloads ? event.content : void 0,
-		metadata: options.includeMetadata ? event.metadata : void 0
+		content: options.includeControlPayloads ? included(event.content) : void 0,
+		metadata: options.includeMetadata ? included(event.metadata) : void 0
 	};
 	if (event.type === "proposal_created") return {
 		type: event.type,
@@ -4909,16 +4910,16 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 		...withSession,
 		timestamp: event.timestamp,
 		proposalId: event.proposalId,
-		title: options.includeControlPayloads ? event.title : void 0,
-		content: options.includeControlPayloads ? event.content : void 0,
+		title: options.includeControlPayloads ? included(event.title) : void 0,
+		content: options.includeControlPayloads ? included(event.content) : void 0,
 		status: event.status
 	};
 	if (event.type === "final") {
 		const sanitizedError = event.error !== void 0 ? {
 			kind: event.error.kind,
-			message: event.error.message,
+			message: included(event.error.message),
 			status: event.error.status,
-			body: options.includeControlPayloads ? event.error.body : void 0
+			body: options.includeControlPayloads ? included(event.error.body) : void 0
 		} : void 0;
 		return {
 			type: event.type,
@@ -4927,8 +4928,8 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
 			timestamp: event.timestamp,
 			status: event.status,
 			reason: event.reason,
-			text: options.includeControlPayloads ? event.text : void 0,
-			metadata: options.includeMetadata ? event.metadata : void 0,
+			text: options.includeControlPayloads ? included(event.text) : void 0,
+			metadata: options.includeMetadata ? included(event.metadata) : void 0,
 			...sanitizedError !== void 0 ? { error: sanitizedError } : {}
 		};
 	}
@@ -4945,9 +4946,9 @@ function sanitizeTask(task, options) {
 		id: task.id,
 		intent: task.intent,
 		domain: task.domain,
-		inputs: options.includeInputs ? task.inputs : task.inputs ? "[redacted]" : void 0,
+		inputs: options.includeInputs ? included(task.inputs) : task.inputs ? "[redacted]" : void 0,
 		requiredKnowledge: task.requiredKnowledge?.map((requirement) => sanitizeKnowledgeRequirement(requirement, options)),
-		metadata: options.includeMetadata ? task.metadata : task.metadata ? "[redacted]" : void 0
+		metadata: options.includeMetadata ? included(task.metadata) : task.metadata ? "[redacted]" : void 0
 	};
 }
 function sanitizeRuntimeSession(session, options) {
@@ -4958,7 +4959,7 @@ function sanitizeRuntimeSession(session, options) {
 		hasResumeToken: Boolean(session.resumeToken),
 		createdAt: session.createdAt,
 		updatedAt: session.updatedAt,
-		metadata: options.includeMetadata ? session.metadata : session.metadata ? "[redacted]" : void 0
+		metadata: options.includeMetadata ? included(session.metadata) : session.metadata ? "[redacted]" : void 0
 	};
 }
 function sanitizeKnowledgeRequirement(requirement, options) {
@@ -5007,8 +5008,8 @@ function sanitizeControlStep(step, options) {
 		index: step.index,
 		decisionType: step.decision.type,
 		reason: step.decision.reason,
-		action: options.includeControlPayloads && step.decision.type === "continue" ? step.decision.action : void 0,
-		result: options.includeControlPayloads && actionOutcome?.ok ? actionOutcome.result : void 0,
+		action: options.includeControlPayloads && step.decision.type === "continue" ? included(step.decision.action) : void 0,
+		result: options.includeControlPayloads && actionOutcome?.ok ? included(actionOutcome.result) : void 0,
 		actionOk: actionOutcome?.ok,
 		actionError: actionOutcome?.ok === false ? actionOutcome.error : void 0,
 		durationMs: actionOutcome?.durationMs,
@@ -5041,10 +5042,17 @@ function summarizeEvals(evals, options) {
 		score: evalResult.score,
 		severity: evalResult.severity,
 		objective: evalResult.objective,
-		detail: options.includeEvalDetails ? evalResult.detail : void 0,
-		evidence: options.includeEvalDetails ? evalResult.evidence : void 0
+		detail: options.includeEvalDetails ? included(evalResult.detail) : void 0,
+		evidence: options.includeEvalDetails ? included(evalResult.evidence) : void 0
 	}));
 }
+/**
+* An opted-in payload still goes through agent-eval's redaction core: the
+* flags decide whether content is shared, never whether credentials are.
+*/
+function included(value) {
+	return value === void 0 ? value : redact(value).value;
+}
 function redactRecord(record) {
 	return Object.fromEntries(Object.keys(record).map((key) => [key, "[redacted]"]));
 }
@@ -5058,7 +5066,7 @@ function pickPublicStreamFields(event) {
 		} : void 0;
 		return {
 			backend: event.backend,
-			message: event.message,
+			message: included(event.message),
 			recoverable: event.recoverable,
 			...sanitizedError !== void 0 ? { error: sanitizedError } : {}
 		};
@@ -5171,25 +5179,30 @@ const GEN_AI = {
 * useless for the runs you most want to look at.
 */
 function createOpenInferenceFileExporter(filePath) {
-	const lines = [];
+	let written = 0;
+	let dropped = 0;
 	let failed;
-	const append = (line) => {
-		try {
-			appendFileSync(filePath, `${line}\n`, "utf8");
-		} catch (error) {
-			failed ??= error instanceof Error ? error : new Error(String(error));
-		}
-	};
 	return {
 		exportSpan(span) {
-			append(JSON.stringify(toOpenInferenceLine(span)));
-			lines.push("");
+			try {
+				appendFileSync(filePath, `${JSON.stringify(toOpenInferenceLine(span))}\n`, "utf8");
+				written += 1;
+			} catch (error) {
+				dropped += 1;
+				failed ??= error instanceof Error ? error : new Error(String(error));
+			}
 		},
 		async flush() {
-			if (failed) throw new Error(`OpenInference file exporter failed writing ${filePath}: ${failed.message}`);
+			if (failed) throw new Error(`OpenInference file exporter failed writing ${filePath} (${dropped} spans dropped): ${failed.message}`);
 		},
-		async shutdown() {
-			lines.length = 0;
+		async shutdown() {},
+		stats() {
+			return {
+				written,
+				dropped,
+				pending: 0,
+				...failed ? { lastError: failed.message } : {}
+			};
 		}
 	};
 }
@@ -5240,68 +5253,172 @@ function toOpenInferenceLine(span) {
 	};
 }
 /**
-* Create an OTEL exporter. Returns undefined when no endpoint is configured.
+* Create an OTLP/HTTP exporter. Returns undefined when no endpoint is configured.
+*
+* One batch is in flight at a time; spans that arrive meanwhile wait in a queue bounded by
+* `maxQueueSize`. Every span ends in exactly one of `written` or `dropped`: a non-2xx response, a
+* network error, a timeout, an OTLP `partialSuccess.rejectedSpans` count and a full queue each count
+* as drops and set `lastError`. Nothing here throws into the caller's run; `flush()` reports the
+* loss, the same rule {@link createOpenInferenceFileExporter} follows.
 */
 function createOtelExporter(config) {
 	const resolvedEndpoint = config?.endpoint ?? (typeof process !== "undefined" ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT : void 0);
 	if (!resolvedEndpoint) return void 0;
-	const endpoint = resolvedEndpoint;
+	const url = `${resolvedEndpoint.replace(/\/+$/, "")}/v1/traces`;
 	const headers = config?.headers ?? parseHeadersFromEnv();
-	const batchSize = config?.batchSize ?? 64;
+	const batchSize = positiveInteger(config?.batchSize, 64);
 	const flushIntervalMs = config?.flushIntervalMs ?? 5e3;
-	const serviceName = config?.serviceName ?? "agent-runtime";
-	const resourceAttrs = config?.resourceAttributes ?? {};
-	const pending = [];
-	let timer;
+	const maxQueueSize = Math.max(positiveInteger(config?.maxQueueSize, 2048), batchSize);
+	const timeoutMs = positiveInteger(config?.timeoutMs, 1e4);
+	const resource = { attributes: toOtelAttributes({
+		"service.name": config?.serviceName ?? "agent-runtime",
+		...config?.resourceAttributes ?? {}
+	}) };
+	const queue = [];
+	let inFlight = 0;
+	let written = 0;
+	let dropped = 0;
+	let droppedAtLastFlush = 0;
+	let lastError;
+	let sending;
 	let stopped = false;
-	const exporter = {
-		exportSpan(span) {
-			if (stopped) return;
-			pending.push(span);
-			if (pending.length >= batchSize) doFlush();
-		},
-		async flush() {
-			await doFlush();
-		},
-		async shutdown() {
-			stopped = true;
-			if (timer !== void 0) {
-				clearInterval(timer);
-				timer = void 0;
-			}
-			await doFlush();
-		}
+	const drop = (count, reason) => {
+		dropped += count;
+		lastError = reason;
 	};
-	timer = setInterval(() => {
-		if (pending.length > 0) doFlush();
-	}, flushIntervalMs);
-	if (typeof timer === "object" && "unref" in timer) timer.unref();
-	async function doFlush() {
-		if (pending.length === 0) return;
-		const batch = pending.splice(0);
+	async function send(batch) {
 		const body = { resourceSpans: [{
-			resource: { attributes: toOtelAttributes({
-				"service.name": serviceName,
-				...resourceAttrs
-			}) },
+			resource,
 			scopeSpans: [{
 				scope: SCOPE,
 				spans: batch
 			}]
 		}] };
-		const url = `${endpoint.replace(/\/+$/, "")}/v1/traces`;
 		try {
-			await fetch(url, {
+			const response = await fetch(url, {
 				method: "POST",
 				headers: {
 					"content-type": "application/json",
 					...headers
 				},
-				body: JSON.stringify(body)
+				body: JSON.stringify(body),
+				signal: AbortSignal.timeout(timeoutMs)
 			});
-		} catch {}
+			const text = await response.text().catch(() => "");
+			if (!response.ok) {
+				const detail = text ? `: ${text.slice(0, 200)}` : "";
+				drop(batch.length, `HTTP ${response.status} from ${url}${detail}`);
+				return;
+			}
+			const rejected = rejectedSpans(text, batch.length);
+			if (rejected.count > 0) drop(rejected.count, `collector rejected ${rejected.count} spans: ${rejected.message}`);
+			written += batch.length - rejected.count;
+		} catch (error) {
+			drop(batch.length, `POST ${url} failed: ${describeFetchError(error)}`);
+		}
+	}
+	/** The single sender: it drains the queue batch by batch until the queue is empty. */
+	function drain() {
+		sending ??= (async () => {
+			try {
+				while (queue.length > 0) {
+					const batch = queue.splice(0, batchSize);
+					inFlight = batch.length;
+					await send(batch);
+					inFlight = 0;
+				}
+			} finally {
+				sending = void 0;
+			}
+		})();
+		return sending;
+	}
+	const timer = setInterval(() => {
+		if (queue.length > 0) drain();
+	}, flushIntervalMs);
+	if (typeof timer === "object" && "unref" in timer) timer.unref();
+	return {
+		exportSpan(span) {
+			if (stopped) {
+				drop(1, "span exported after the exporter stopped");
+				return;
+			}
+			if (queue.length + inFlight >= maxQueueSize) {
+				drop(1, `queue full: ${maxQueueSize} spans already waiting on ${url}`);
+				return;
+			}
+			queue.push(span);
+			if (queue.length >= batchSize) drain();
+		},
+		async flush() {
+			await drain();
+			const lost = dropped - droppedAtLastFlush;
+			droppedAtLastFlush = dropped;
+			if (lost > 0) throw new Error(`OTLP exporter dropped ${lost} spans since the last flush: ${lastError}`);
+		},
+		async shutdown() {
+			stopped = true;
+			clearInterval(timer);
+			await drain();
+		},
+		stats() {
+			return {
+				written,
+				dropped,
+				pending: queue.length + inFlight,
+				...lastError !== void 0 ? { lastError } : {}
+			};
+		}
+	};
+}
+/**
+* Spans a 2xx OTLP/HTTP response still refused. The spec lets a collector accept a request and
+* reject part of it through `partialSuccess.rejectedSpans`; reading only the status would count
+* those spans as delivered. An empty or non-JSON body is a full success.
+*/
+function rejectedSpans(text, batchLength) {
+	if (!text.trim()) return {
+		count: 0,
+		message: ""
+	};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			count: 0,
+			message: ""
+		};
 	}
-	return exporter;
+	if (parsed === null || typeof parsed !== "object") return {
+		count: 0,
+		message: ""
+	};
+	const partial = parsed.partialSuccess;
+	if (partial === null || typeof partial !== "object") return {
+		count: 0,
+		message: ""
+	};
+	const { rejectedSpans: raw, errorMessage } = partial;
+	const count = typeof raw === "string" ? Number(raw) : typeof raw === "number" ? raw : 0;
+	if (!Number.isSafeInteger(count) || count <= 0) return {
+		count: 0,
+		message: ""
+	};
+	return {
+		count: Math.min(count, batchLength),
+		message: typeof errorMessage === "string" && errorMessage ? errorMessage : "no message"
+	};
+}
+/** Node's fetch reports every socket failure as "fetch failed"; the cause names which one. */
+function describeFetchError(error) {
+	if (!(error instanceof Error)) return String(error);
+	const cause = error.cause;
+	const code = cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" ? cause.code : void 0;
+	return code ? `${error.message} (${code})` : error.message;
+}
+function positiveInteger(value, fallback) {
+	return value !== void 0 && Number.isSafeInteger(value) && value > 0 ? value : fallback;
 }
 /**
 * Convert a LoopTraceEvent into an OtelSpan for export.
@@ -5382,8 +5499,10 @@ function buildRuntimeEventOtelSpans(events, traceId, parentSpanId, options = {})
 			"tangle.runtime.event": serialized(record)
 		};
 		let name = `tangle.runtime.${event.type}`;
+		if (parentSpanId) attrs[ATTR.parentConfidence] = "explicit";
 		if (event.type === "tool_call" || event.type === "tool_result") {
 			name = `agent.${event.type}`;
+			if (event.type === "tool_call") attrs[ATTR.spanKind] = "TOOL";
 			attrs["tool.name"] = event.toolName;
 			if (event.toolCallId) attrs["tool.call_id"] = event.toolCallId;
 			const mcp = mcpIdentity(event.toolName);
@@ -5393,6 +5512,7 @@ function buildRuntimeEventOtelSpans(events, traceId, parentSpanId, options = {})
 			if (payload !== void 0) attrs[event.type === "tool_call" ? "tool.input" : "tool.output"] = serialized(payload);
 		} else if (event.type === "llm_call") {
 			name = "gen_ai.client.inference";
+			attrs[ATTR.spanKind] = "LLM";
 			attrs["gen_ai.request.model"] = event.model;
 			if (event.tokensIn !== void 0) attrs["gen_ai.usage.input_tokens"] = event.tokensIn;
 			if (event.tokensOut !== void 0) attrs["gen_ai.usage.output_tokens"] = event.tokensOut;
@@ -5446,11 +5566,25 @@ function buildLoopOtelSpans(events, traceId, rootParentSpanId) {
 		kind: 1,
 		startTimeUnixNano: msToNs(node.startMs),
 		endTimeUnixNano: msToNs(node.endMs),
-		attributes: toOtelAttributes(node.attrs),
+		attributes: toOtelAttributes({
+			...node.attrs,
+			[ATTR.spanKind]: LOOP_SPAN_KIND[node.kind],
+			...node.parentSpanId === void 0 && rootParentSpanId ? { [ATTR.parentConfidence]: "explicit" } : {}
+		}),
 		status: { code: node.error ? 2 : 1 }
 	}));
 }
 /**
+* The declared kind of each loop level. An iteration span carries its own token total, and an
+* undeclared span with tokens reads as an LLM call, so declaring AGENT keeps those tokens from
+* being counted a second time beside the model-call spans beneath it.
+*/
+const LOOP_SPAN_KIND = {
+	loop: "CHAIN",
+	round: "CHAIN",
+	branch: "AGENT"
+};
+/**
 * Sink-neutral core behind {@link buildLoopOtelSpans}: reconstruct the
 * loop → round → branch span tree from one run's ordered `LoopTraceEvent`
 * stream. Consumed by the OTEL mapper above and by the MCP delegation
@@ -5506,10 +5640,15 @@ function buildLoopSpanNodes(events) {
 	const iterStartTs = /* @__PURE__ */ new Map();
 	const placementByIdx = /* @__PURE__ */ new Map();
 	let currentRoundId;
+	/** Plan round index → its span id, so an iteration joins the round it records (`groupId`). */
+	const roundIdByIndex = /* @__PURE__ */ new Map();
 	let pendingRound;
 	const flushRound = (endMs) => {
 		if (!pendingRound) return;
-		out.push(make(pendingRound.id, rootId, "loop.round", "round", pendingRound.start, endMs, pendingRound.attrs));
+		out.push(make(pendingRound.id, rootId, "loop.round", "round", pendingRound.start, endMs, {
+			...pendingRound.attrs,
+			[ATTR.parentConfidence]: "explicit"
+		}));
 		pendingRound = void 0;
 	};
 	for (const e of events) {
@@ -5537,6 +5676,7 @@ function buildLoopSpanNodes(events) {
 					attrs
 				};
 				currentRoundId = id;
+				roundIdByIndex.set(roundIdx, id);
 				break;
 			}
 			case "loop.iteration.started": {
@@ -5583,6 +5723,8 @@ function buildLoopSpanNodes(events) {
 				if (err) attrs["tangle.loop.error"] = err;
 				const gid = num(p.groupId);
 				if (gid !== void 0) attrs["tangle.loop.iteration.group_id"] = gid;
+				const recordedRoundId = gid === void 0 ? void 0 : roundIdByIndex.get(gid);
+				attrs[ATTR.parentConfidence] = recordedRoundId ? "explicit" : "heuristic";
 				const par = num(p.parentIndex);
 				if (par !== void 0) attrs["tangle.loop.iteration.parent_index"] = par;
 				const dur = num(p.durationMs);
@@ -5590,7 +5732,7 @@ function buildLoopSpanNodes(events) {
 				const preview = str(p.outputPreview);
 				if (preview) attrs["tangle.loop.iteration.output_preview"] = preview;
 				Object.assign(attrs, placementByIdx.get(idx) ?? {});
-				out.push(make(generateSpanId(), currentRoundId ?? rootId, "loop.iteration", "branch", start, e.timestamp, attrs, err !== void 0));
+				out.push(make(generateSpanId(), recordedRoundId ?? currentRoundId ?? rootId, "loop.iteration", "branch", start, e.timestamp, attrs, err !== void 0));
 				break;
 			}
 			case "loop.decision":
@@ -5931,11 +6073,11 @@ const HARNESS_ROOTS = Object.freeze({
 	]),
 	codex: Object.freeze([".codex/sessions", ".codex/history.jsonl"]),
 	opencode: Object.freeze([
-		".local/share/opencode/storage",
-		".local/share/opencode/export",
-		".local/share/opencode/log",
 		".opencode/sessions",
-		".opencode/messages"
+		".opencode/messages",
+		".local/share/opencode/export",
+		".local/share/opencode/storage",
+		".local/share/opencode/log"
 	]),
 	pi: Object.freeze([".pi/agent/sessions"])
 });
@@ -5973,6 +6115,126 @@ function harnessTranscriptUnavailable(reason) {
 	return unavailable$2(reason);
 }
 /**
+* Read one executor's harness-transcript receipt without letting a broken port escape.
+*
+* The three answers this has to keep apart, because #1214 and #1244 are both about an artifact
+* that reads as coverage without being coverage:
+*   - `available`                              the transcript survived;
+*   - a reason the CAPTURE produced            a box existed and could not be read;
+*   - `executor-exposes-no-transcript`     this runtime has no transcript to offer at all;
+*   - `execution-never-started`                no environment was ever created (the executor's
+*                                              own seed, set before `create`);
+*   - `capture-did-not-run`                    the port answered nothing, so the capture was
+*                                              skipped rather than attempted and failed.
+*
+* Mirrors the supervise scope's `readInteractiveSession`: an absence is always a named reason,
+* never `undefined`. The scope reads each child with it, and `supervise` reads the root with it.
+*/
+function readHarnessTranscript(executor) {
+	if (!executor.harnessTranscript) return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+	let reported;
+	try {
+		reported = executor.harnessTranscript();
+	} catch {
+		return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+	}
+	if (reported === void 0) return harnessTranscriptUnavailable("capture-did-not-run");
+	const capture = reported;
+	if (capture.status === "captured" && capture.artifact) return capture;
+	if (capture.status === "unavailable" && capture.reason) return capture;
+	return harnessTranscriptUnavailable("executor-exposes-no-transcript");
+}
+/**
+* Bounds on the subagent export, per capture. The capture runs after every turn and again at
+* release, so they bound how long a turn's end or a teardown can wait on it; each session they
+* leave out is named in `skipped`.
+*/
+const MAX_SUBAGENT_EXPORTS = 32;
+const SUBAGENT_EXPORT_SECONDS = 120;
+/** The script starts no export after SUBAGENT_EXPORT_SECONDS and bounds each one at 30 s, so it
+*  ends inside this. It is passed to `exec`, because the Sandbox SDK's default is 30 s. */
+const SUBAGENT_EXPORT_EXEC_MS = 180 * 1e3;
+const SUBAGENT_EXPORT_DIR = "~/.local/share/opencode/export";
+/**
+* The export, run in the box. For each sidecar record it reads the runtime home and the parent
+* session, collects the subagent sessions its messages name, and writes `opencode export` of each
+* one under `export`, where the capture reads it. It prints one `<state> <sessionId>` line per
+* subagent: `exported`, `failed`, or `unexported` (over a bound), then `done`. Every capture exports again,
+* because a later turn can continue a subagent and the store changes with every turn; an export
+* takes about 2 s in a Tangle box. Each export goes to a temporary file first, so a failed or
+* interrupted export never leaves a partial file for the capture to read.
+*/
+const SUBAGENT_EXPORT_SCRIPT = String.raw`cd "$HOME" 2>/dev/null || exit 0
+out="$HOME/.local/share/opencode/export"
+t=""; command -v timeout >/dev/null 2>&1 && t="timeout 30"
+start=$(date +%s); n=0
+for rec in .opencode/sessions/*.json; do
+  [ -f "$rec" ] || continue
+  h=$(sed -n 's/.*"providerSessionHome"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$rec" | head -n 1)
+  p=$(sed -n 's/.*"providerSessionId"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$rec" | head -n 1)
+  db="$h/.local/share/opencode/opencode.db"
+  case "$h" in /*) [ -f "$db" ] || continue ;; *) continue ;; esac
+  ids=$(grep -rhoE '<task id=\\?"ses_[A-Za-z0-9]+|task_id: ses_[A-Za-z0-9]+|"sessionId"[[:space:]]*:[[:space:]]*"ses_[A-Za-z0-9]+' ".opencode/messages/$(basename "$rec" .json)" 2>/dev/null | grep -oE 'ses_[A-Za-z0-9]+' | sort -u)
+  for id in $ids; do
+    [ "$id" = "$p" ] && continue
+    n=$((n + 1))
+    if [ "$n" -gt ${MAX_SUBAGENT_EXPORTS} ] || [ $(($(date +%s) - start)) -ge ${SUBAGENT_EXPORT_SECONDS} ]; then echo "unexported $id"; continue; fi
+    mkdir -p "$out" && tmp=$(mktemp) || { echo "failed $id"; continue; }
+    if HOME="$h" XDG_DATA_HOME="$h/.local/share" XDG_CONFIG_HOME="$h/.config" XDG_STATE_HOME="$h/.local/state" XDG_CACHE_HOME="$h/.cache" OPENCODE_DISABLE_AUTOUPDATE=1 OPENCODE_DISABLE_MODELS_FETCH=1 $t opencode export "$id" > "$tmp" 2>/dev/null && [ -s "$tmp" ]; then
+      mv "$tmp" "$out/$id.json" && echo "exported $id"
+    else
+      rm -f "$tmp"; echo "failed $id"
+    fi
+  done
+done
+echo done`;
+/**
+* Export each opencode subagent session a Tangle box's sidecar names, so the capture carries the
+* subagent's own steps (#1264).
+*
+* The sidecar runs opencode under a private runtime home and records the parent session under
+* `.opencode/sessions` and `.opencode/messages`. A `task` subagent runs in a child session, and
+* those records name it only in the tool's result (`<task id="ses_…">`, or `task_id: ses_…` on a
+* failure). Its steps are only in the runtime home's `opencode.db`, which a text capture cannot
+* carry. Each sidecar record names that home as `providerSessionHome`, so `opencode export` reads
+* the child from there. A shared-box worker exports its own subagents after each turn (#1371) and
+* keeps no sidecar record, so the export finds nothing to do for it.
+*
+* Returns the sessions it could not export, as `skipped` entries. An export that did not run, or
+* stopped before its `done` line, is named once, because the subagents it did not reach are
+* unknown.
+*/
+async function exportSubagentSessions(environment, signal) {
+	if (!environment.exec || signal?.aborted) return [];
+	let stdout;
+	try {
+		stdout = (await environment.exec(SUBAGENT_EXPORT_SCRIPT, {
+			timeoutMs: SUBAGENT_EXPORT_EXEC_MS,
+			...signal ? { signal } : {}
+		})).stdout ?? "";
+	} catch {
+		return [{
+			path: SUBAGENT_EXPORT_DIR,
+			reason: "subagent-export-did-not-run"
+		}];
+	}
+	const lines = stdout.split("\n").map((line) => line.trim());
+	const gaps = [];
+	for (const line of lines) {
+		const match = /^(failed|unexported) (ses_[A-Za-z0-9]+)$/u.exec(line);
+		if (match === null) continue;
+		gaps.push({
+			path: `${SUBAGENT_EXPORT_DIR}/${match[2]}.json`,
+			reason: match[1] === "failed" ? "subagent-export-failed" : "subagent-export-over-bound"
+		});
+	}
+	if (!lines.includes("done")) gaps.push({
+		path: SUBAGENT_EXPORT_DIR,
+		reason: "subagent-export-incomplete"
+	});
+	return gaps;
+}
+/**
 * Enumerate candidate transcript paths inside the environment.
 *
 * `find -printf` is given the roots and prints one `size<TAB>path` line per file. A missing root
@@ -6033,12 +6295,13 @@ async function captureHarnessTranscript(environment, harness, signal) {
 	if (harness === void 0) return unavailable$2("unknown-harness");
 	const roots = HARNESS_ROOTS[harness];
 	if (!roots) return unavailable$2("unknown-harness");
+	const unexported = harness === "opencode" ? await exportSubagentSessions(environment, signal) : [];
 	const enumerated = await enumerate(environment, roots, signal);
 	if (enumerated === void 0) return unavailable$2("enumeration-failed");
 	const { paths } = enumerated;
-	if (paths.length === 0 && enumerated.omitted.length === 0) return unavailable$2("no-transcript");
+	if (paths.length === 0 && enumerated.omitted.length === 0 && unexported.length === 0) return unavailable$2("no-transcript");
 	const files = [];
-	const skipped = [...enumerated.omitted];
+	const skipped = [...unexported, ...enumerated.omitted];
 	let total = 0;
 	for (const path of paths) {
 		if (signal?.aborted) {
@@ -6112,6 +6375,73 @@ async function captureHarnessTranscript(environment, harness, signal) {
 	});
 }
 /**
+* A transcript this process holds in memory, one JSON line per record, as a capture under the same
+* bounds a box's session files get: each file at most MAX_FILE_BYTES, all files together at most
+* MAX_TOTAL_BYTES. Lines fill `<name>-000.jsonl`, `<name>-001.jsonl`, ... in order, and a line is
+* never split. A line longer than one file, and every line past the total, is named in `skipped`
+* with its line number, so a cut transcript never reads as the whole one.
+*/
+function harnessTranscriptFromLines(harness, name, lines) {
+	if (lines.length === 0) return unavailable$2("no-transcript");
+	const files = [];
+	const skipped = [];
+	let total = 0;
+	let chunk = [];
+	let chunkBytes = 0;
+	const flush = () => {
+		if (chunk.length === 0) return;
+		const content = `${chunk.join("\n")}\n`;
+		files.push(Object.freeze({
+			path: `${name}-${String(files.length).padStart(3, "0")}.jsonl`,
+			bytes: Buffer.byteLength(content, "utf8"),
+			content
+		}));
+		chunk = [];
+		chunkBytes = 0;
+	};
+	lines.forEach((line, index) => {
+		const bytes = Buffer.byteLength(line, "utf8") + 1;
+		const where = `${name} line ${index + 1}`;
+		if (bytes > MAX_FILE_BYTES) {
+			skipped.push({
+				path: where,
+				reason: "file-exceeds-byte-bound"
+			});
+			return;
+		}
+		if (total + bytes > MAX_TOTAL_BYTES) {
+			skipped.push({
+				path: where,
+				reason: "total-byte-budget-exhausted"
+			});
+			return;
+		}
+		if (chunkBytes + bytes > MAX_FILE_BYTES) flush();
+		chunk.push(line);
+		chunkBytes += bytes;
+		total += bytes;
+	});
+	flush();
+	if (files.length === 0) return Object.freeze({
+		status: "unavailable",
+		reason: "nothing-carried",
+		skipped: Object.freeze(skipped)
+	});
+	const artifact = Object.freeze({
+		schemaVersion: 1,
+		harness,
+		files: Object.freeze(files),
+		skipped: Object.freeze(skipped)
+	});
+	return Object.freeze({
+		status: "captured",
+		artifact,
+		fileCount: files.length,
+		totalBytes: total,
+		skippedCount: skipped.length
+	});
+}
+/**
 * Persist a capture under its own content ref and return the receipt a settlement carries.
 *
 * The scope calls this, not the executor: storage stays out of every provider and destroy site,
@@ -6267,81 +6597,40 @@ function publicCreateOptions(create) {
 }
 //#endregion
 //#region src/redact.ts
-const redactedMarker = "[redacted]";
-/** Secret-bearing key names: when an object key matches, its value is fully
-*  replaced regardless of the value's own content. Lowercased compare. */
-const secretKeyPattern = /(api[-_]?key|secret|token|password|passwd|authorization|auth|private[-_]?key|credential|access[-_]?key|client[-_]?secret|session[-_]?(id|token)|cookie|bearer)/i;
-/** AgentProfile's numeric model limits describe compute, not credentials. */
-const tokenLimitKeyPattern = /^max(?:VisibleOutput|Reasoning|TotalOutput)Tokens$/;
-/** In-value secret/PII patterns scrubbed from any string, regardless of key. */
-const valuePatterns = [
-	/\bBearer\s+[A-Za-z0-9._\-+/=]{8,}/gi,
-	/\b(?:sk|pk|rk|ak)[-_][A-Za-z0-9_-]{12,}/g,
-	/\bgh[pousr]_[A-Za-z0-9]{20,}/g,
-	/\bAKIA[0-9A-Z]{16}\b/g,
-	/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-	/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g
-];
-/** Secret assignments embedded inside an otherwise opaque string, including
-* serialized JSON and log-style `key=value` text. */
-const secretAssignmentPattern = /((?:"|')?(?:api[-_]?key|secret|token|password|passwd|authorization|auth|private[-_]?key|credential|access[-_]?key|client[-_]?secret|session[-_]?(?:id|token)|cookie|bearer)(?:"|')?\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}]+)/gi;
-/** Scrub a single string of in-value secret/PII patterns. */
-function scrubString(input) {
-	let out = input;
-	for (const pattern of valuePatterns) out = out.replace(pattern, redactedMarker);
-	return out.replace(secretAssignmentPattern, `$1${redactedMarker}`);
-}
 /**
-* The built-in redactor. Walks objects and arrays; replaces values under
-* secret-bearing keys wholesale; scrubs in-value patterns from every string.
-* Cycle-safe (a seen-set short-circuits self-referential payloads to
-* `'[circular]'`), depth-bounded, and total — never throws on customer input.
+* Redaction for values that may leave the Runtime process. The built-in
+* redactor is agent-eval's redaction core (`@tangle-network/agent-eval/traces`,
+* default profile): credentials found by field name or value shape are
+* replaced whole, email, card, SSN and phone values in place, and token counts
+* such as `inputTokens` or `max_tokens` are kept. A customer with
+* domain-specific PII supplies their own `redact` hook.
+*
+* This is narrower than `src/sanitize.ts`, which drops fields of the runtime's
+* *event envelope* unless the caller opts in: here the value is opaque customer
+* payload, so the scrub is value-shaped, not schema-shaped.
+*
+* @experimental
+*/
+/**
+* The built-in redactor. Cycle-safe, depth-bounded and total: it never throws
+* on customer input and never mutates it.
 */
 function defaultRedactor(value) {
-	return walk(value, /* @__PURE__ */ new WeakSet(), 0);
-}
-const maxDepth = 32;
-function walk(value, seen, depth) {
-	if (depth > maxDepth) return "[truncated]";
-	if (typeof value === "string") return scrubString(value);
-	if (value === null || typeof value !== "object") return value;
-	if (seen.has(value)) return "[circular]";
-	seen.add(value);
-	if (Array.isArray(value)) return value.map((item) => walk(item, seen, depth + 1));
-	const out = {};
-	for (const [key, v] of Object.entries(value)) {
-		const tokenLimit = tokenLimitKeyPattern.test(key) && typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
-		if (secretKeyPattern.test(key) && !tokenLimit) {
-			out[key] = redactedMarker;
-			continue;
-		}
-		out[key] = walk(v, seen, depth + 1);
-	}
-	return out;
+	return redact(value).value;
 }
 /** Stable identity input for saved work that depends on built-in redaction behavior. */
 function defaultRedactorIdentityMaterial() {
-	const patternIdentity = (pattern) => ({
-		source: pattern.source,
-		flags: pattern.flags
-	});
 	return {
-		marker: redactedMarker,
-		secretKeyPattern: patternIdentity(secretKeyPattern),
-		tokenLimitKeyPattern: patternIdentity(tokenLimitKeyPattern),
-		valuePatterns: valuePatterns.map(patternIdentity),
-		secretAssignmentPattern: patternIdentity(secretAssignmentPattern),
-		maxDepth,
-		scrubString: Function.prototype.toString.call(scrubString),
-		walk: Function.prototype.toString.call(walk),
-		defaultRedactor: Function.prototype.toString.call(defaultRedactor)
+		core: "@tangle-network/agent-eval/traces redact",
+		profile: "default",
+		version: REDACTION_VERSION$1
 	};
 }
 /**
 * Resolve the redactor a client uses. A caller-supplied hook handles
 * domain-specific values first, then the built-in scrubber still removes
-* common credentials and email addresses. Returning `false` is the explicit
-* opt-out for already-reviewed public values.
+* credentials and personal data. Returning `false` is the explicit opt-out for
+* already-reviewed public values.
 */
 function resolveRedactor(redact) {
 	if (redact === false) return (value) => value;
@@ -7404,7 +7693,8 @@ function assertRetainedRunReplayMaterial(provider, replay, admission) {
 	}, identity, retainedContextTransfer(replay.turn.contextTransfer)));
 }
 function retainedRunIntent(options, identity, contextTransfer) {
-	const requestedProfileDigest = canonicalCandidateDigest(options.environment.profile);
+	const { profile } = options.environment;
+	const requestedProfileDigest = typeof profile === "string" ? canonicalCandidateDigest(profile) : canonicalAgentProfileDigest(profile);
 	const requestDigest = canonicalCandidateDigest({
 		kind: "retained-run-intent.v1",
 		provider: options.provider.name,
@@ -8263,6 +8553,7 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 	let workspaceCapturePromise;
 	let workspaceCleanupPromise;
 	let retainedReleasePromise;
+	let releaseReadTried = false;
 	let workspaceOutcome;
 	let workspacePreservationRequired = false;
 	let workspaceRunActive = false;
@@ -8615,6 +8906,11 @@ function createProviderExecutor(provider, profile, ctx, options, placement) {
 						environment = target;
 						resetWorkspaceState(target);
 					}
+					if (harnessTranscript.status !== "captured" && !releaseReadTried) {
+						releaseReadTried = true;
+						const capture = await captureHarnessTranscript(target, profile.harness, signal);
+						if (capture.status === "captured") harnessTranscript = capture;
+					}
 					const result = await destroyEnvironment(signal);
 					if (!result.destroyed) return [receipt(false, result.detail, result.permanent)];
 					pending = false;
@@ -8966,7 +9262,7 @@ async function providerExecutionSource(args, turn, signal) {
 		const dispatched = [...admissions].reverse().find((admission) => admission.phase === "dispatched");
 		const intent = admissions.find((admission) => admission.phase === "intent");
 		const environmentAdmission = admissions.find((admission) => admission.phase === "environment");
-		if (args.recovering) {
+		if (args.recovering && admissions.length > 0) {
 			if (!intent) throw new Error("retained provider execution has no original intent");
 			assertRetainedRunReplayMaterial(args.provider, material, intent);
 		}
@@ -9014,7 +9310,7 @@ async function providerExecutionSource(args, turn, signal) {
 			if (recovered.outcome !== "recovered") throw new Error(`retained provider execution is ${recovered.outcome}`);
 			handle = recovered.handle;
 		} else {
-			if (args.recovering) throw new Error("retained provider execution has no durable admission");
+			if (args.recovering && admissions.length > 0) throw new Error("retained provider execution has no durable admission");
 			handle = await startRetainedRun({
 				provider: args.provider,
 				...material,
@@ -16636,6 +16932,7 @@ var FileResultBlobStore = class {
 		return `${this.dir}/${outRef.replace(/:/g, "-")}.json`;
 	}
 };
+/** @internal shared with the SQL-backed store. */
 function encodeResultBlob(outRef, artifact) {
 	const detached = detachedSnapshot(artifact, "result blob");
 	assertContentAddress(outRef, detached);
@@ -16648,11 +16945,21 @@ function encodeResultBlob(outRef, artifact) {
 		text
 	};
 }
+/** @internal shared with the SQL-backed store. */
 function assertContentAddress(outRef, artifact) {
 	const expected = contentAddress(artifact);
 	if (outRef !== expected) throw new Error(`blob outRef '${outRef}' does not match the artifact content hash '${expected}'; a content-addressed store refuses a mismatched ref (breaks the replay invariant)`);
 }
 /**
+* Append every event as one grouped publication where the journal supports it (`appendEvents`),
+* preserving legacy per-event appends otherwise — the SQL contexts' fenced head advances once.
+* @internal
+*/
+async function appendSpawnEvents(journal, root, events) {
+	if (journal.appendEvents !== void 0) return journal.appendEvents(root, events);
+	for (const event of events) await journal.appendEvent(root, event);
+}
+/**
 * In-memory `SpawnJournal`. Appends are observed-committed only; the impl enforces
 * the corruption guards a durable replay rests on:
 *  - an event before `beginTree` is a corrupted tree (fail loud),
@@ -17085,6 +17392,7 @@ function servedIdentityParts(model) {
 	};
 }
 /** One validation implementation for memory, durable append, and cold replay. */
+/** @internal shared with the SQL-backed store. */
 var SpawnEventIndex = class {
 	root;
 	nodes = /* @__PURE__ */ new Map();
@@ -17752,6 +18060,96 @@ function executionTaskPrompt$1(task, configuredPrompt) {
 	return prompt;
 }
 //#endregion
+//#region src/runtime/supervise/router-transcript.ts
+/**
+* The conversation of a router-brained agent, kept as it happens.
+*
+* A router-brained agent (`harness` omitted or `cli-base`) runs its tool loop in this process, so
+* its whole conversation is in the loop's `messages` and nowhere else. Before this, Runtime
+* metered each turn's usage and tool-call names and kept nothing the agent said, saw, or asked a
+* tool to do: a 316-agent tree on 2026-09-24 settled with 0 of 316 transcripts, and the 37 agents
+* still running when its driver process stopped left no record at all (agent-runtime#1377).
+*
+* The recorder keeps each message once, in the order the model saw it, and serves two readers:
+*   - each turn's `agent.turn` event carries the messages that turn added (the loop's inputs since
+*     the previous turn, then the reply), so an observer journal holds every agent's conversation
+*     while the run is live;
+*   - `capture()` returns the whole conversation as a harness transcript, so the agent settles
+*     with an `available` receipt instead of `executor-exposes-no-transcript`.
+*
+* The loop mutates `messages` in place: it appends the reply it was given, each tool result, and
+* any inbox message, and a compaction replaces the middle with a distilled note. The recorder
+* therefore reads new messages twice per turn, before compaction can remove them and again when
+* the model is called, and it identifies a message by object identity. The loop's own copy of a
+* reply is skipped, because the recorder already kept the reply when the model returned it.
+*/
+/** The harness name a router-brained agent's transcript carries. */
+const ROUTER_TRANSCRIPT_HARNESS = "router";
+/**
+* The most bytes of one message's `content` a turn event carries. A longer content is cut, and
+* the message says so with its full length, so a reader never takes a cut message for the whole.
+* The settled transcript keeps the full content, within the bounds of `harnessTranscriptFromLines`.
+*/
+const TURN_CONTENT_BYTES = 256 * 1024;
+function createRouterTranscript() {
+	const kept = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	let turnStart = 0;
+	let replyEchoPending = false;
+	let live;
+	const observe = (messages) => {
+		live = messages;
+		for (const message of messages) {
+			if (message === null || typeof message !== "object" || seen.has(message)) continue;
+			seen.add(message);
+			if (replyEchoPending) {
+				replyEchoPending = false;
+				if (message.role === "assistant") continue;
+			}
+			kept.push(message);
+		}
+	};
+	return {
+		observe,
+		reply(reply) {
+			const message = {
+				role: "assistant",
+				content: reply.content ?? "",
+				...reply.toolCalls && reply.toolCalls.length > 0 ? { tool_calls: reply.toolCalls.map((call) => ({
+					id: call.id,
+					type: "function",
+					function: {
+						name: call.name,
+						arguments: call.arguments
+					}
+				})) } : {}
+			};
+			kept.push(message);
+			replyEchoPending = true;
+			const added = kept.slice(turnStart).map(forTurnEvent);
+			turnStart = kept.length;
+			return added;
+		},
+		capture() {
+			if (live !== void 0) observe(live);
+			if (kept.length === 0) return harnessTranscriptUnavailable("execution-never-started");
+			return harnessTranscriptFromLines(ROUTER_TRANSCRIPT_HARNESS, "conversation", kept.map((message) => JSON.stringify(message)));
+		}
+	};
+}
+function forTurnEvent(message) {
+	const content = message.content;
+	if (typeof content !== "string") return message;
+	const bytes = Buffer.byteLength(content);
+	if (bytes <= 262144) return message;
+	return {
+		...message,
+		content: Buffer.from(content).subarray(0, TURN_CONTENT_BYTES).toString("utf8"),
+		contentBytes: bytes,
+		contentCut: true
+	};
+}
+//#endregion
 //#region src/runtime/supervise/sandbox-session.ts
 /** Ceiling on continuation turns. Turn 0 is the task; every later turn is a folded steer, so
 *  this bounds how many times a supervisor may redirect ONE worker before it must respawn. */
@@ -18363,6 +18761,7 @@ const routerInlineExecutor = (spec, ctx) => {
 	const requestIdentity = routerRequestIdentity(ctx);
 	const controller = linkAbort(ctx.signal);
 	let artifact;
+	const transcript = createRouterTranscript();
 	const executionId = ctx.node?.nodeId ?? `router-request-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
 	let executor;
@@ -18370,6 +18769,7 @@ const routerInlineExecutor = (spec, ctx) => {
 		runtime: "router",
 		async execute(task, signal) {
 			const messages = taskToMessages(task, spec, profileExecution.systemPrompt);
+			transcript.observe(messages);
 			const started = Date.now();
 			const linked = linkAbort(signal, controller.signal).signal;
 			const extraBody = {
@@ -18407,6 +18807,10 @@ const routerInlineExecutor = (spec, ctx) => {
 				...requestIdentity
 			}));
 			if (r.model !== void 0) recordRuntimeOwnedProviderModel(executor, r.model);
+			transcript.reply({
+				content: r.content,
+				toolCalls: "toolCalls" in r ? r.toolCalls : []
+			});
 			const spent = {
 				...addResourceSpend(r.resources),
 				iterations: 1,
@@ -18442,6 +18846,7 @@ const routerInlineExecutor = (spec, ctx) => {
 			};
 			return artifact;
 		},
+		harnessTranscript: () => transcript.capture(),
 		cancel(_request) {
 			controller.abort("executor cancelled");
 			return Promise.resolve(localAbortCancellation("the Router chat-completions API exposes no cancel operation; the local request was aborted and the provider may still bill the completion"));
@@ -18542,12 +18947,14 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 	const controller = linkAbort(ctx.signal);
 	const inbox = createInbox();
 	let artifact;
+	const transcript = createRouterTranscript();
 	const executionId = ctx.node?.nodeId ?? `router-tools-run-${randomUUID()}`;
 	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
 	let executor;
 	executor = attestRuntimeOwnedExecutor({
 		runtime: "router",
 		deliver: (m) => inbox.deliver(m),
+		harnessTranscript: () => transcript.capture(),
 		async execute(task, signal) {
 			const started = Date.now();
 			const messages = seam.initialMessages ? taskToMessages({ messages: [...seam.initialMessages, {
@@ -18586,6 +18993,7 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 					interruptSig.addEventListener("abort", abortTurn, { once: true });
 					const cleanup = () => external.removeEventListener("abort", abortTurn);
 					let res;
+					transcript.observe(messages);
 					try {
 						recordRuntimeOwnedProviderAttemptStart(executor);
 						res = await (profileExecution.stream === true ? streamRouterChatWithTools : routerChatWithTools)({
@@ -18622,6 +19030,10 @@ const routerToolsInlineExecutor = (spec, ctx) => {
 					}
 					cleanup();
 					turns += 1;
+					transcript.reply({
+						content: res.content,
+						toolCalls: res.toolCalls
+					});
 					const priorResources = resources;
 					resources = addResourceSpend(resources, res.resources).resources;
 					resources = addResourceSpend(Object.fromEntries(Object.entries(resources ?? {}).map(([name, value]) => [name, {
@@ -21025,14 +21437,15 @@ function settledNodeEvidence(subject, settlement, settledAt) {
 		trace: detachedSnapshot(settlement.trace, "worker trace evidence")
 	};
 }
-/** The `agent.child` payload of the release: the settlement restated as released, `settledAt`
-*  kept at the settlement instant and `metered` omitted so the driver's inference is not summed
-*  twice. The sweep and the resume heal emit it from the same builder. */
-function releasedChildPayload(subject, settlement, settledAt, releasedAt) {
+/** The `agent.child` payload of a closed retained slot: the settlement restated with the state
+*  the slot closed in, `settledAt` kept at the settlement instant and `metered` omitted so the
+*  driver's inference is not summed twice. The sweep, the final close and the resume heal emit
+*  it from the same builder. */
+function releasedChildPayload(subject, settlement, settledAt, releasedAt, retainedExecution = "released") {
 	return {
 		childId: subject.id,
 		status: "down",
-		retainedExecution: "released",
+		retainedExecution,
 		...settlement.retainedPendingCause === void 0 ? {} : { retainedPendingCause: settlement.retainedPendingCause },
 		releasedAt,
 		...settlement.outRef === void 0 ? {} : { outRef: settlement.outRef },
@@ -21180,7 +21593,7 @@ async function prepareInterruptedExecutors(opts, events, signal, now, parentId =
 			continue;
 		}
 		const admissions = current.flatMap((event) => event.kind === "execution-admitted" ? [event.admission] : []);
-		if (!opts.recoverExecutor || admissions.length === 0 && !node.ownedTreeRoot) continue;
+		if (!opts.recoverExecutor || admissions.length === 0 && !node.ownedTreeRoot && (opts.journal.appendEvents === void 0 || latestInput === void 0)) continue;
 		const taskRef = inputs[0]?.taskRef;
 		if (!node.profileRef || !taskRef || !node.identity?.profileDigest || !node.identity.taskDigest) throw new RuntimeRunStateError(`cannot recover '${node.id}' without exact profile and task bytes`);
 		const profile = agentProfileSchema.parse(await opts.blobs.get(node.profileRef));
@@ -21273,7 +21686,11 @@ async function assertRecordedResult(node, result, events, opts) {
 * The keyed assignments a prior journal proves: every `spawned` event carrying a `key`, resolved
 * against the replayed settlements. A key spawned more than once (a retry chain) resolves to its
 * LATEST attempt — iterate in ordinal order so later spawns overwrite earlier ones. A spawned
-* event with no matching settlement is `in-doubt`: the process died with it in flight.
+* event with no matching settlement is `in-doubt`: the process died with it in flight — UNLESS
+* the spawn's own runtime proves the execution cannot have outlived the process (`inline`, the
+* same predicate the budget layer charges no uncertain reservation for), in which case the resume
+* itself is the terminal evidence and the key resolves `down` with a derived reason, so a re-spawn
+* under the same key retries instead of wedging in-doubt.
 */
 function keyedAssignments(events, settled) {
 	const byId = new Map(settled.map((s) => [s.handle.id, s]));
@@ -21283,7 +21700,13 @@ function keyedAssignments(events, settled) {
 		if (ev.key === void 0) continue;
 		if (ev.identity === void 0) throw new RuntimeRunStateError(`supervisor: keyed node '${ev.id}' has no durable execution identity`);
 		const s = byId.get(ev.id);
-		keys.set(ev.key, s === void 0 ? {
+		keys.set(ev.key, s === void 0 ? ev.runtime === "inline" ? {
+			id: ev.id,
+			label: ev.label,
+			identity: ev.identity,
+			state: "down",
+			reason: `interrupted: the process died with '${ev.label}' in flight and its '${ev.runtime}' runtime cannot outlive that process, so the resume proves the attempt dead`
+		} : {
 			id: ev.id,
 			label: ev.label,
 			identity: ev.identity,
@@ -22620,6 +23043,7 @@ const runtimeOwnedProviderMeters = /* @__PURE__ */ new WeakMap();
 const pauseRecorders = /* @__PURE__ */ new WeakMap();
 const recoveryStarters = /* @__PURE__ */ new WeakMap();
 const retainedReleasers = /* @__PURE__ */ new WeakMap();
+const retainedSlotClosers = /* @__PURE__ */ new WeakMap();
 const teardownRetriers = /* @__PURE__ */ new WeakMap();
 const teardownRetriable = /* @__PURE__ */ new WeakMap();
 /** The retained owner environments a scope's last release could not confirm destroyed. */
@@ -22707,6 +23131,25 @@ async function releaseRetainedEnvironments(scope) {
 	return unconfirmedTeardowns(scope);
 }
 /**
+* @internal Close the cursor slot of every retained child this scope and its nested scopes still
+* hold open, once the settlement is final and the release and its retries are done.
+*
+* The release sweep closes a slot only when it confirms the environment destroyed, and nothing
+* else ever closed the rest: a refused delete, a teardown probe that failed after a destroy, or an
+* admission that timed out before `create` named an environment. Measured on the Discovery fleet
+* of 2026-09-23/24 (Runtime 0.249.1 to 0.261.0): 338 of 1,620 agents never settled, so they had no
+* terminal record, no spend but the reservation ceiling, and no transcript receipt (#1301). A
+* settlement under `retainedAtSettlement: 'release'` is final, so no process will recover these
+* executions. Each slot closes with the settlement the driver already received, under the seq it
+* saw, marked `retainedExecution: 'release-unconfirmed'`. The environment it may still hold stays
+* named by its `teardown-unconfirmed` record for a sweeper. Never call this on a run a later
+* process may resume.
+*/
+async function closeRetainedSlots(scope) {
+	const close = retainedSlotClosers.get(scope);
+	if (close) await close();
+}
+/**
 * @internal Everything this scope cannot prove destroyed: its settled children whose teardown is
 * unconfirmed and, after a release, the retained owner environment that release could not
 * confirm. Read live, so a later retry that confirms a node removes it.
@@ -22877,6 +23320,14 @@ function createScope(args) {
 			identity: prior.identity,
 			reason: prior.settled.reason
 		});
+	} else if (prior.state === "down" && prior.settled === void 0) {
+		if (prior.identity === void 0) continue;
+		keyed.set(key, {
+			state: "down",
+			id: prior.id,
+			identity: prior.identity,
+			reason: prior.reason ?? "interrupted: resume proved the prior attempt dead"
+		});
 	} else if (prior.identity !== void 0) keyed.set(key, {
 		state: "in-doubt",
 		id: prior.id,
@@ -23225,6 +23676,7 @@ function createScope(args) {
 				askTeardown,
 				...executor.heldEnvironments ? { readHeldEnvironments: executor.heldEnvironments.bind(executor) } : {},
 				...nestedTeardownScopes.has(executor) ? { readNestedScope: nestedTeardownScopes.get(executor) } : {},
+				...executor.harnessTranscript ? { readTranscriptAtRelease: () => persistHarnessTranscript(readHarnessTranscript(executor), args.blobs) } : {},
 				teardownAttempts: 0,
 				abortChild: (reason) => controller.abort(reason)
 			};
@@ -23241,29 +23693,31 @@ function createScope(args) {
 			});
 			const profileRef = contentAddress(spec.profile);
 			const taskRef = identity?.taskDigest === void 0 ? void 0 : contentAddress(task);
-			const spawnCommitted = recovery ? Promise.resolve() : args.blobs.put(profileRef, spec.profile).then(() => taskRef === void 0 ? void 0 : args.blobs.put(taskRef, task)).then(() => args.journal.appendEvent(args.root, {
-				kind: "spawned",
-				id,
-				parent: args.parentId,
-				label: opts.label,
-				...opts.key !== void 0 ? { key: opts.key } : {},
-				...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
-				...opts.successorOf === void 0 ? {} : { successorOf: opts.successorOf },
-				budget: opts.budget,
-				runtime: executor.runtime,
-				...ownedTreeRoot === void 0 ? {} : { ownedTreeRoot },
-				...identity ? { identity } : {},
-				profileRef,
-				seq: ordinal,
-				at: new Date(now()).toISOString()
-			})).then(async () => {
-				if (taskRef !== void 0) await args.journal.appendEvent(args.root, {
+			const spawnCommitted = recovery ? Promise.resolve() : args.blobs.put(profileRef, spec.profile).then(() => taskRef === void 0 ? void 0 : args.blobs.put(taskRef, task)).then(async () => {
+				const events = [{
+					kind: "spawned",
+					id,
+					parent: args.parentId,
+					label: opts.label,
+					...opts.key !== void 0 ? { key: opts.key } : {},
+					...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
+					...opts.successorOf === void 0 ? {} : { successorOf: opts.successorOf },
+					budget: opts.budget,
+					runtime: executor.runtime,
+					...ownedTreeRoot === void 0 ? {} : { ownedTreeRoot },
+					...identity ? { identity } : {},
+					profileRef,
+					seq: ordinal,
+					at: new Date(now()).toISOString()
+				}];
+				if (taskRef !== void 0) events.push({
 					kind: "execution-input",
 					id,
 					taskRef,
 					seq: ordinal,
 					at: new Date(now()).toISOString()
 				});
+				await appendSpawnEvents(args.journal, args.root, events);
 			}).then(async () => {
 				if (args.workerTraceUnpropagated === void 0 || workerTrace === void 0) return;
 				await args.journal.appendEvent(args.root, {
@@ -23393,6 +23847,7 @@ function createScope(args) {
 					childId: id,
 					label: opts.label,
 					...opts.assignmentId === void 0 ? {} : { assignmentId: opts.assignmentId },
+					...opts.key === void 0 ? {} : { key: opts.key },
 					...opts.successorOf === void 0 ? {} : { successorOf: opts.successorOf },
 					runtime: executor.runtime,
 					...identity ? { identity } : {},
@@ -23916,24 +24371,44 @@ function createScope(args) {
 		const prior = released.length > 0 ? await args.journal.loadTree(args.root) ?? [] : [];
 		for (const { child, receipts } of released) {
 			for (const receipt of receipts) await appendEnvironmentTeardown(args.journal, args.root, child.id, receipt, new Date(now()).toISOString());
-			if (child.cleanupConfirmed && child.recoveryPending === true && child.resolved?.kind === "down" && child.settledSeq !== void 0 && child.settledAt !== void 0 && !prior.some((event) => event.id === child.id && closesCursorSlot(event))) {
-				child.budgetViolation = child.retainedViolation;
-				const settledAt = child.settledAt;
-				await args.journal.appendEvent(args.root, terminalDownEvent(child, child.resolved, child.settledSeq, new Date(settledAt).toISOString(), "released"));
-				child.retainedExecution = "released";
-				const releasedAt = now();
-				notifyRuntimeHookEvent(args.hooks, {
-					id: `${child.id}:released`,
-					runId: args.root,
-					target: "agent.child",
-					phase: "after",
-					timestamp: releasedAt,
-					stepIndex: child.settledSeq,
-					parentId: args.parentId,
-					payload: releasedChildPayload(child, child.resolved, settledAt, releasedAt)
-				}, { signal: args.signal });
-			}
+			if (child.cleanupConfirmed) await closeRetainedSlot(child, "released", prior);
+		}
+	});
+	const closeRetainedSlot = async (child, state, prior) => {
+		if (child.recoveryPending !== true || child.resolved?.kind !== "down" || child.settledSeq === void 0 || child.settledAt === void 0 || child.retainedExecution === "released" || child.retainedExecution === "release-unconfirmed" || prior.some((event) => event.id === child.id && closesCursorSlot(event))) return;
+		child.budgetViolation = child.retainedViolation;
+		const settledAt = child.settledAt;
+		let settlement = child.resolved;
+		if (settlement.harnessTranscript?.status !== "available" && child.readTranscriptAtRelease) {
+			const atRelease = await child.readTranscriptAtRelease();
+			if (atRelease.status === "available") settlement = {
+				...settlement,
+				harnessTranscript: atRelease
+			};
+		}
+		await args.journal.appendEvent(args.root, terminalDownEvent(child, settlement, child.settledSeq, new Date(settledAt).toISOString(), state));
+		child.retainedExecution = state;
+		const closedAt = now();
+		notifyRuntimeHookEvent(args.hooks, {
+			id: `${child.id}:${state}`,
+			runId: args.root,
+			target: "agent.child",
+			phase: "after",
+			timestamp: closedAt,
+			stepIndex: child.settledSeq,
+			parentId: args.parentId,
+			payload: releasedChildPayload(child, settlement, settledAt, closedAt, state)
+		}, { signal: args.signal });
+	};
+	retainedSlotClosers.set(scope, async () => {
+		for (const child of children.values()) {
+			const nested = child.readNestedScope?.();
+			if (nested !== void 0) await closeRetainedSlots(nested);
 		}
+		const open = [...children.values()].filter((child) => child.recoveryPending === true && !child.cleanupConfirmed && isTerminalNodeStatus(child.status) && child.retainedExecution !== "released" && child.retainedExecution !== "release-unconfirmed");
+		if (open.length === 0) return;
+		const prior = await args.journal.loadTree(args.root) ?? [];
+		for (const child of open) await closeRetainedSlot(child, "release-unconfirmed", prior);
 	});
 	registerScopeRetainedOwner(scope, {
 		rootId: args.root,
@@ -24033,7 +24508,7 @@ async function recordScopeOwnerMaterialization(scope, runtime, declaration, bind
 /** @internal Kernel identity for constructing the exact deferred owner executor. */
 /**
 * @internal Each driver attempt of the scope owner is its own execution attempt. A driver retry
-* after a failed drive, and the `repromptOnUnmet` re-entry after an unmet completion check, both
+* after a failed drive, and the continuation re-entry after an unmet completion check, both
 * run the harness again and report a new execution binding; the journal keys owner bindings by
 * attempt id, so every attempt after the first is given a fresh kernel-minted id and its
 * published flags are cleared, and the new binding lands beside the earlier ones. The first
@@ -25039,35 +25514,6 @@ function downRecord(reason, infra, trace, metered, providerModel, outRef, harnes
 		...outRef === void 0 ? {} : { outRef }
 	};
 }
-/**
-* Read one executor's harness-transcript receipt without letting a broken port escape.
-*
-* The three answers this has to keep apart, because #1214 and #1244 are both about an artifact
-* that reads as coverage without being coverage:
-*   - `available`                              the transcript survived;
-*   - a reason the CAPTURE produced            a box existed and could not be read;
-*   - `executor-exposes-no-transcript`     this runtime has no transcript to offer at all;
-*   - `execution-never-started`                no environment was ever created (the executor's
-*                                              own seed, set before `create`);
-*   - `capture-did-not-run`                    the port answered nothing, so the capture was
-*                                              skipped rather than attempted and failed.
-*
-* Mirrors `readInteractiveSession` above: an absence is always a named reason, never `undefined`.
-*/
-function readHarnessTranscript(executor) {
-	if (!executor.harnessTranscript) return harnessTranscriptUnavailable("executor-exposes-no-transcript");
-	let reported;
-	try {
-		reported = executor.harnessTranscript();
-	} catch {
-		return harnessTranscriptUnavailable("executor-exposes-no-transcript");
-	}
-	if (reported === void 0) return harnessTranscriptUnavailable("capture-did-not-run");
-	const capture = reported;
-	if (capture.status === "captured" && capture.artifact) return capture;
-	if (capture.status === "unavailable" && capture.reason) return capture;
-	return harnessTranscriptUnavailable("executor-exposes-no-transcript");
-}
 /** The one place an absent interactive process is spelled, so every refusal reads the same. */
 function noInteractiveSession(reason) {
 	return Object.freeze({
@@ -25487,6 +25933,493 @@ function unreportedSpend(total, prior) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/continuation.ts
+/**
+* The continuation: what a manager with a completion check is told when its turn ends and the
+* check is unmet, and the one rule that decides whether it is sent back.
+*
+* Measured on discovery-lab before this module (2026-09-24, 670 settled runs, 1,596 re-entries):
+* 1,565 re-entries followed a failed turn and resent the original task, and 31 carried note text.
+* The note Runtime wrote itself held seven fixed lines and no field for the check's verdict. Of 40
+* episodes where the director ended on its own and the outside check disagreed, 33 were told
+* nothing before they ended. 100 of 236 resubmits sent the identical packet. So the director
+* mostly graded itself, and when it was wrong it heard nothing it could use.
+*
+* The design (discovery `docs/38-one-loop-and-continuation.md`) makes three things single, and
+* this module holds the part Runtime owns:
+*
+*  - ONE CHECK. A check reading is a {@link CheckVerdict}: pass, the items it read, the composite,
+*    and one `FAIL <item> <where>: <reason>` line per failed item. The same check decides
+*    `submit_result`, runs when a turn ends without an accepted result, scores the finished run,
+*    and ranks versions. A check that could not run gives no verdict ({@link CheckUnavailableError}),
+*    and the loop pauses instead of blaming the director.
+*  - ONE RESEND RULE. {@link ContinuationPolicy} is required for a manager with a check. It holds a
+*    deadline and `maxBarren`, the re-entered turns in a row that may end without progress. There
+*    is no re-prompt count and no default: a retry default in source is a research decision.
+*  - ONE NOTE. {@link composeContinuationNote} writes it. Runtime owns the facts and their order;
+*    the {@link ContinuationProfile} owns every instruction word, so an optimizer can change the
+*    words without touching code. A play may append a section, never remove or rewrite one.
+*
+* Evidence behind the note's shape: located errors help (given the first mistake's true location,
+* fix rates rose 23.5 to 43.9 points, Tyen 2023); unsupported pressure does not (threats and tips
+* had no significant effect, Wharton 2025; challenges without evidence flipped correct answers,
+* FlipFlop); repeated summaries drop detail while itemized additions do not (ACE). So the note is
+* a list of located facts, findings are added and marked resolved rather than rewritten, and the
+* profile, not this file, decides how blunt the words are.
+*/
+/**
+* The check could not run: its box did not start, its judge's provider refused, its program
+* crashed. It is not a verdict on the result. Inside a run the loop pauses, as it does for an
+* unavailable upstream, and the refusal tells the director its result was not judged.
+*/
+var CheckUnavailableError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CheckUnavailableError";
+	}
+};
+/** Read a check function's return value into a verdict. Anything but `true` or a passing verdict
+*  is a failure: a check fails closed. */
+function checkVerdictOf(outcome) {
+	if (outcome === true) return { pass: true };
+	if (typeof outcome !== "object" || outcome === null || Array.isArray(outcome)) return { pass: false };
+	const raw = outcome;
+	const items = typeof raw.items === "object" && raw.items !== null && !Array.isArray(raw.items) ? Object.fromEntries(Object.entries(raw.items).filter((entry) => typeof entry[1] === "number" && Number.isFinite(entry[1]))) : void 0;
+	const failures = Array.isArray(raw.failures) ? raw.failures.filter((line) => typeof line === "string" && line.trim() !== "") : void 0;
+	return Object.freeze({
+		pass: raw.pass === true,
+		...items === void 0 ? {} : { items: Object.freeze(items) },
+		...finite(raw.composite) ? { composite: raw.composite } : {},
+		...finite(raw.threshold) ? { threshold: raw.threshold } : {},
+		...failures === void 0 ? {} : { failures: Object.freeze(failures) },
+		...typeof raw.review === "string" && raw.review.trim() !== "" ? { review: raw.review.trim() } : {}
+	});
+}
+/**
+* Read an agent-eval `JudgeScore` from a check program into a verdict.
+*
+* Each dimension is a checked item. `notes` lines that start with `FAIL ` are the failures; the
+* remaining lines are the check's review. The verdict passes when `composite >= threshold` and the
+* score is not marked `failed`; a `failed` score means the judge itself did not run, which is
+* {@link CheckUnavailableError}, not a verdict.
+*/
+function verdictFromJudgeScore(score, threshold) {
+	if (score.failed === true) throw new CheckUnavailableError(`the check's judge did not run: ${score.notes}`);
+	const lines = score.notes.split("\n").map((line) => line.trimEnd());
+	const failures = lines.filter((line) => line.startsWith("FAIL "));
+	const review = lines.filter((line) => !line.startsWith("FAIL ") && line.trim() !== "").join("\n");
+	return checkVerdictOf({
+		pass: score.composite >= threshold,
+		items: score.dimensions,
+		composite: score.composite,
+		threshold,
+		failures,
+		...review === "" ? {} : { review }
+	});
+}
+/** Items that fail in `verdict`: every item below 1, or the named items of its FAIL lines. */
+function failedItems(verdict) {
+	if (verdict.items !== void 0) return Object.entries(verdict.items).filter(([, value]) => value < 1).map(([name]) => name);
+	return (verdict.failures ?? []).map((line) => line.slice(5).split(/[\s:]/u)[0] ?? "");
+}
+/** Items that pass in `verdict`. */
+function passedItems(verdict) {
+	return Object.entries(verdict.items ?? {}).filter(([, value]) => value >= 1).map(([name]) => name);
+}
+/** Resolve and check a policy before any compute. Returns the deadline in epoch ms. */
+function admitContinuationPolicy(policy, context) {
+	if (typeof policy !== "object" || policy === null) throw new ValidationError$1(`${context}: continuation must be an object`);
+	const deadlineMs = typeof policy.deadline === "string" ? Date.parse(policy.deadline) : policy.deadline;
+	if (typeof deadlineMs !== "number" || !Number.isFinite(deadlineMs) || deadlineMs <= 0) throw new ValidationError$1(`${context}: continuation.deadline must be a finite time (epoch ms or ISO 8601)`);
+	if (!Number.isInteger(policy.maxBarren) || policy.maxBarren < 1) throw new ValidationError$1(`${context}: continuation.maxBarren must be an integer >= 1`);
+	if (policy.failures !== "verbatim" && policy.failures !== "off") throw new ValidationError$1(`${context}: continuation.failures must be 'verbatim' or 'off'`);
+	if (policy.panel !== "on" && policy.panel !== "off") throw new ValidationError$1(`${context}: continuation.panel must be 'on' or 'off'`);
+	if (policy.bar !== "on" && policy.bar !== "off") throw new ValidationError$1(`${context}: continuation.bar must be 'on' or 'off'`);
+	if (policy.panel === "on") {
+		if (typeof policy.runPanel !== "function") throw new ValidationError$1(`${context}: continuation.panel 'on' needs runPanel`);
+		const usd = policy.panelUsd;
+		if (usd === void 0 || !finite(usd.perContinuation) || !finite(usd.perRun) || usd.perContinuation <= 0 || usd.perRun < usd.perContinuation) throw new ValidationError$1(`${context}: continuation.panel 'on' needs panelUsd with 0 < perContinuation <= perRun`);
+	}
+	if (policy.append !== void 0 && typeof policy.append !== "function") throw new ValidationError$1(`${context}: continuation.append must be a function`);
+	admitContinuationProfile(policy.profile, context);
+	return deadlineMs;
+}
+/** The facts a profile template may name. */
+const CONTINUATION_FACTS = [
+	"composite",
+	"threshold",
+	"failed",
+	"total",
+	"reads",
+	"owed",
+	"settled",
+	"delivered",
+	"continuation"
+];
+const factNames = new Set(CONTINUATION_FACTS);
+const placeholder = /\{([a-zA-Z]+)\}/gu;
+function admitContinuationProfile(profile, context) {
+	if (typeof profile !== "object" || profile === null) throw new ValidationError$1(`${context}: continuation.profile must be an object`);
+	if (typeof profile.id !== "string" || profile.id.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.id must be non-empty`);
+	const texts = [
+		["opening", profile.opening],
+		["plan", profile.plan],
+		["rules", profile.rules],
+		...Object.entries(profile.headings ?? {}).map(([key, value]) => [`headings.${key}`, value]),
+		...profile.barRule === void 0 ? [] : [["barRule", profile.barRule]]
+	];
+	for (const key of [
+		"failures",
+		"protected",
+		"changed",
+		"findings",
+		"bar",
+		"plan",
+		"rules"
+	]) if (typeof profile.headings?.[key] !== "string") throw new ValidationError$1(`${context}: continuation.profile.headings.${key} must be a string`);
+	for (const [key, text] of texts) {
+		if (typeof text !== "string") throw new ValidationError$1(`${context}: continuation.profile.${key} must be a string`);
+		for (const match of text.matchAll(placeholder)) if (!factNames.has(match[1] ?? "")) throw new ValidationError$1(`${context}: continuation.profile.${key} names {${match[1]}}, which is not a fact Runtime supplies (${CONTINUATION_FACTS.join(", ")})`);
+	}
+	if (profile.review !== void 0) {
+		if (typeof profile.review !== "string" || profile.review.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.review must be non-empty`);
+		for (const match of profile.review.matchAll(placeholder)) if (![
+			"version",
+			"path",
+			"score"
+		].includes(match[1] ?? "")) throw new ValidationError$1(`${context}: continuation.profile.review names {${match[1]}}; it may name {version}, {path} and {score}`);
+	}
+	if (profile.opening.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.opening must be non-empty`);
+	for (const [index, question] of (profile.questions ?? []).entries()) if (typeof question !== "string" || question.trim() === "") throw new ValidationError$1(`${context}: continuation.profile.questions[${index}] must be a non-empty string`);
+}
+/** Findings reach the note only when every citation resolves, at least two distinct spans are
+*  cited, and the independent verifier agreed. The best method in Who&When found the failing step
+*  14.2% of the time, so an unverified finding is noise with a citation. */
+function admitFinding(finding) {
+	if (!finding.verified) return false;
+	if (finding.citations.length === 0) return false;
+	if (!finding.citations.every((citation) => citation.resolved)) return false;
+	return new Set(finding.citations.map((citation) => citation.uri)).size >= 2;
+}
+/** About 1,500 tokens of findings. */
+const FINDINGS_CHAR_CAP = 6e3;
+/**
+* Rank the admitted findings by how many failed items they explain, drop repeats, and keep them
+* within the note's cap. Earlier findings stay as they were written (ACE: itemized additions keep
+* detail that repeated rewrites lose); a finding whose items all pass now is marked resolved.
+*/
+function distillFindings(prior, proposed, failing, continuation) {
+	const key = (claim) => claim.toLowerCase().replace(/\s+/gu, " ").trim();
+	const known = new Set(prior.map((finding) => key(finding.claim)));
+	const carried = prior.map((finding) => finding.resolvedAt === void 0 && (finding.items?.length ?? 0) > 0 && (finding.items ?? []).every((item) => !failing.has(item)) ? {
+		...finding,
+		resolvedAt: continuation
+	} : finding);
+	const fresh = proposed.filter(admitFinding).filter((finding) => {
+		const k = key(finding.claim);
+		if (known.has(k)) return false;
+		known.add(k);
+		return true;
+	}).map((finding) => ({
+		finding,
+		links: (finding.items ?? []).filter((item) => failing.has(item)).length
+	})).sort((a, b) => b.links - a.links);
+	const out = [...carried];
+	let used = carried.filter((finding) => finding.resolvedAt === void 0).reduce((sum, finding) => sum + finding.claim.length, 0);
+	for (const { finding } of fresh) {
+		if (used + finding.claim.length > FINDINGS_CHAR_CAP) break;
+		used += finding.claim.length;
+		out.push({
+			...finding,
+			admittedAt: continuation
+		});
+	}
+	return out;
+}
+/** Expand the profile's question templates over the failed items and the settled workers. */
+function expandQuestions(templates, failing, workers) {
+	const out = [];
+	for (const template of templates) {
+		const hasItem = template.includes("{item}");
+		const hasWorker = template.includes("{worker}");
+		if (!hasItem && !hasWorker) {
+			out.push(template);
+			continue;
+		}
+		const items = hasItem ? failing : [""];
+		const each = hasWorker ? workers.map((worker) => `${worker.id} (${worker.label})`) : [""];
+		for (const item of items) for (const worker of each) out.push(template.replaceAll("{item}", item).replaceAll("{worker}", worker));
+	}
+	return out;
+}
+/**
+* Write one continuation note, sections 1 to 8 of docs/38. Section 9, the run's state, is
+* `composeReentryTask`, which wraps this text. Pure: the same input writes the same note.
+*/
+function composeContinuationNote(input) {
+	const { profile, verdict } = input;
+	const items = verdict?.items ?? {};
+	const total = Object.keys(items).length;
+	const failing = verdict === void 0 ? [] : failedItems(verdict);
+	const facts = {
+		composite: verdict?.composite === void 0 ? "unknown" : format(verdict.composite),
+		threshold: verdict?.threshold === void 0 ? "unknown" : format(verdict.threshold),
+		failed: verdict === void 0 || total === 0 && (verdict.failures?.length ?? 0) === 0 ? "unknown" : String(failing.length),
+		total: total === 0 ? "unknown" : String(total),
+		reads: String(input.reads),
+		owed: input.owed?.trim() || "not described",
+		settled: String(input.progress.settledCount),
+		delivered: String(input.progress.deliveredCount ?? 0),
+		continuation: String(input.continuation)
+	};
+	const fill = (text) => text.replace(placeholder, (_, name) => facts[name] ?? `{${name}}`);
+	const sections = [verdict === void 0 ? "No result has reached the check yet. The run ends only when a result passes it through submit_result." : verdict.pass ? "The check passes on the current state, but no result was submitted. Call submit_result to end the run." : fill(profile.opening).trim()];
+	const section = (heading, body) => {
+		if (body.length === 0) return;
+		sections.push([...heading.trim() === "" ? [] : [`## ${fill(heading)}`], ...body].join("\n"));
+	};
+	if (input.failures === "verbatim" && verdict !== void 0) {
+		const lines = verdict.failures ?? [];
+		const shown = lines.slice(0, 40);
+		const more = lines.length - shown.length;
+		section(profile.headings.failures, [...shown, ...more > 0 ? [input.canReadMore ? `${more} more failure lines: call read_continuation with continuation ${input.continuation}.` : `${more} more failure lines are not shown.`] : []]);
+		const passing = passedItems(verdict);
+		section(profile.headings.protected, passing.length === 0 ? [] : [passing.join(", ")]);
+		if (input.previous !== void 0) {
+			const before = new Set(failedItems(input.previous));
+			const now = new Set(failing);
+			const fixed = [...before].filter((item) => !now.has(item));
+			const broke = [...now].filter((item) => !before.has(item));
+			section(profile.headings.changed, [
+				...fixed.length === 0 ? [] : [`Now passing: ${fixed.join(", ")}.`],
+				...broke.length === 0 ? [] : [`Newly failing: ${broke.join(", ")}.`],
+				...fixed.length === 0 && broke.length === 0 ? ["No item changed since the last note."] : [],
+				...input.previous.composite !== void 0 && verdict.composite !== void 0 ? [`Composite: ${format(input.previous.composite)} then ${format(verdict.composite)}.`] : []
+			]);
+		}
+	}
+	if (input.findings !== void 0) {
+		const open = input.findings.filter((finding) => finding.resolvedAt === void 0);
+		const resolved = input.findings.filter((finding) => finding.resolvedAt === input.continuation);
+		section(profile.headings.findings, [...open.map((finding) => `- [hypothesis] ${finding.claim}` + (finding.items?.length ? ` (items: ${finding.items.join(", ")})` : "") + ` Evidence: ${finding.citations.map((citation) => citation.uri).join(", ")}`), ...resolved.map((finding) => `- [resolved] ${finding.claim}`)]);
+	}
+	if (input.bar !== void 0 && verdict !== void 0) {
+		const body = [];
+		if (profile.barRule?.trim()) body.push(fill(profile.barRule).trim());
+		for (const [item, value] of Object.entries(items)) {
+			const best = input.bar.best?.verdict.items?.[item];
+			body.push(`- ${item}: ${value >= 1 ? "passes" : `fails (${format(value)})`}` + (best === void 0 ? "" : ` / ${input.bar.best?.label}: ${best >= 1 ? "passes" : `fails (${format(best)})`}`));
+		}
+		if (input.bar.best?.verdict.composite !== void 0) body.push(`Best version ${input.bar.best.label}: composite ${format(input.bar.best.verdict.composite)}.`);
+		if (input.bar.reference?.trim()) body.push(`Reference result: ${input.bar.reference.trim()}`);
+		if (verdict.review?.trim()) body.push(`The check's review: ${verdict.review.trim()}`);
+		section(profile.headings.bar, body);
+	}
+	section(profile.headings.plan, profile.plan.trim() === "" ? [] : [fill(profile.plan).trim()]);
+	section(profile.headings.rules, [...profile.rules.trim() === "" ? [] : [fill(profile.rules).trim()], ...input.sealed ? ["The score comes from cases you cannot see."] : []]);
+	for (const appended of input.appended ?? []) section(appended.heading, appended.text.trim() === "" ? [] : [appended.text.trim()]);
+	return sections.join("\n\n");
+}
+function summarizeVerdict(verdict) {
+	if (verdict === void 0) return null;
+	const total = Object.keys(verdict.items ?? {}).length;
+	return {
+		pass: verdict.pass,
+		...verdict.composite === void 0 ? {} : { composite: verdict.composite },
+		...total === 0 ? {} : {
+			failed: failedItems(verdict).length,
+			total
+		}
+	};
+}
+function noteDigest(note) {
+	return `sha256:${createHash("sha256").update(note).digest("hex")}`;
+}
+/** A run directory's continuation files: the root's at `<runDir>/continuations/<n>/`, a nested
+*  manager's at `<runDir>/continuations/managers/<owner>/<n>/`. */
+const CONTINUATIONS_DIR = "continuations";
+/**
+* Write one continuation's files under `<dir>/<n>/`: `note.md`, `verdict.json`, and
+* `panel.jsonl` when the panel ran. The director reads them through `read_continuation`, because
+* its box cannot read the driver's run directory.
+*/
+async function writeContinuationFiles(dir, continuation, files) {
+	const at = join(dir, String(continuation));
+	await mkdir(at, { recursive: true });
+	await writeFile(join(at, "note.md"), `${files.note}\n`, "utf8");
+	await writeFile(join(at, "verdict.json"), `${JSON.stringify(files.verdict ?? null, null, 2)}\n`, "utf8");
+	if (files.panel !== void 0) await writeFile(join(at, "panel.jsonl"), files.panel.map((line) => JSON.stringify(line)).join("\n") + (files.panel.length ? "\n" : ""), "utf8");
+}
+/** The best composite across `reads`, or `undefined` when no read scored. */
+function bestComposite(reads) {
+	let best;
+	for (const read of reads) {
+		const value = read.verdict?.composite;
+		if (value !== void 0 && (best === void 0 || value > best)) best = value;
+	}
+	return best;
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function format(value) {
+	return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/u, "");
+}
+/** Build the continuation state for one manager with a check. */
+function createContinuationKeeper(input) {
+	const { policy } = input;
+	const failures = input.feedback === "pass-only" ? "off" : policy.failures;
+	const entries = [];
+	const notes = [];
+	let findings = [];
+	let panelUsd = 0;
+	let panelUsdKnown = true;
+	const latestVerdict = () => {
+		const reads = input.reads();
+		for (let i = reads.length - 1; i >= 0; i -= 1) {
+			const read = reads[i];
+			if (read?.verdict !== void 0) return {
+				verdict: read.verdict,
+				read: read.read
+			};
+		}
+		return { read: 0 };
+	};
+	const closePrevious = () => {
+		const last = entries.at(-1);
+		const lastNote = notes.at(-1);
+		if (last === void 0 || lastNote === void 0) return;
+		const latest = latestVerdict();
+		entries[entries.length - 1] = {
+			...last,
+			after: latest.read > lastNote.read ? summarizeVerdict(latest.verdict) : null
+		};
+	};
+	return {
+		async compose(context) {
+			closePrevious();
+			const continuation = entries.length + 1;
+			const { verdict, read } = latestVerdict();
+			const failing = verdict === void 0 ? [] : failedItems(verdict);
+			let panelRecord;
+			let panelLines;
+			if (policy.panel === "on" && policy.runPanel !== void 0 && policy.panelUsd !== void 0) {
+				const workers = input.workers();
+				const questions = expandQuestions(policy.profile.questions ?? [], failing, workers);
+				const left = policy.panelUsd.perRun - panelUsd;
+				const usdCap = Math.min(policy.panelUsd.perContinuation, left);
+				if (questions.length > 0 && usdCap > 0 && panelUsdKnown) {
+					const result = await policy.runPanel({
+						continuation,
+						task: input.task,
+						...verdict === void 0 ? {} : { verdict },
+						reads: input.reads(),
+						questions,
+						...input.rootStreamPath === void 0 ? {} : { rootStreamPath: input.rootStreamPath },
+						workers,
+						...policy.best === void 0 ? {} : { bar: policy.best },
+						...policy.reference === void 0 ? {} : { reference: policy.reference },
+						usdCap,
+						signal: context.signal
+					});
+					if (result.usd === null) panelUsdKnown = false;
+					else panelUsd += result.usd;
+					findings = distillFindings(findings, result.findings, new Set(failing), continuation);
+					panelRecord = {
+						asked: questions.length,
+						proposed: result.findings.length,
+						admitted: findings.filter((finding) => finding.admittedAt === continuation).length,
+						usd: result.usd
+					};
+					panelLines = [...result.findings.map((finding) => ({
+						kind: "finding",
+						admitted: admitFinding(finding),
+						...finding
+					})), ...result.receipts === void 0 ? [] : [{
+						kind: "receipts",
+						receipts: result.receipts
+					}]];
+				} else panelRecord = {
+					asked: 0,
+					proposed: 0,
+					admitted: 0,
+					usd: 0
+				};
+			}
+			const appended = policy.append ? await policy.append({
+				continuation,
+				...verdict === void 0 ? {} : { verdict },
+				reads: input.reads(),
+				signal: context.signal
+			}) : void 0;
+			const note = composeContinuationNote({
+				profile: policy.profile,
+				continuation,
+				...verdict === void 0 ? {} : { verdict },
+				...notes.at(-1)?.verdict === void 0 ? {} : { previous: notes.at(-1)?.verdict },
+				reads: input.reads().length,
+				failures,
+				...policy.panel === "on" ? { findings } : {},
+				...policy.bar === "on" ? { bar: {
+					...policy.best === void 0 ? {} : { best: policy.best },
+					...policy.reference === void 0 ? {} : { reference: policy.reference }
+				} } : {},
+				...appended === void 0 ? {} : { appended: [appended] },
+				...input.owed === void 0 ? {} : { owed: input.owed },
+				progress: context.progress,
+				canReadMore: input.canReadMore,
+				...input.sealed === true ? { sealed: true } : {}
+			});
+			notes.push({
+				note,
+				...verdict === void 0 ? {} : { verdict },
+				...panelLines === void 0 ? {} : { panel: panelLines },
+				read
+			});
+			entries.push({
+				continuation,
+				attempt: context.attempt,
+				noteDigest: noteDigest(note),
+				profile: policy.profile.id,
+				switches: {
+					failures,
+					panel: policy.panel,
+					bar: policy.bar
+				},
+				before: summarizeVerdict(verdict),
+				after: null,
+				...panelRecord === void 0 ? {} : { panel: panelRecord },
+				appended: appended === void 0 ? 0 : 1
+			});
+			if (input.dir !== void 0) await writeContinuationFiles(input.dir, continuation, {
+				note,
+				...verdict === void 0 ? {} : { verdict },
+				...panelLines === void 0 ? {} : { panel: panelLines }
+			});
+			return note;
+		},
+		read(continuation) {
+			const index = continuation === void 0 ? notes.length - 1 : continuation - 1;
+			const entry = notes[index];
+			if (entry === void 0) return {
+				found: false,
+				reason: notes.length === 0 ? "no continuation has been sent in this run" : `continuations run from 1 to ${notes.length}`
+			};
+			return {
+				found: true,
+				continuation: index + 1,
+				note: entry.note,
+				verdict: failures === "off" && entry.verdict !== void 0 ? { pass: entry.verdict.pass } : entry.verdict ?? null,
+				findings: findings.filter((finding) => finding.admittedAt <= index + 1)
+			};
+		},
+		entries() {
+			closePrevious();
+			return entries.map((entry) => ({ ...entry }));
+		}
+	};
+}
+//#endregion
 //#region src/runtime/supervise/driver-retry.ts
 /**
 * Root-driver retry — the root gets the same second chance a worker's transport already has.
@@ -25534,22 +26467,21 @@ function unreportedSpend(total, prior) {
 * driver that RETURNED with the contract unmet ended the run silently — 376 of 376 winning lab runs
 * ended on this loop's own `stop: 'completed'`, with the completion gate left to label the result
 * rather than to change it. A completed drive whose contract is unmet is now a first-class moment:
-* `reprompt.maxReprompts` re-enters the driver with the unmet items, and every re-entry crosses the
-* same budget, deadline, and abort bounds. Successful continuations do not consume the failure
-* retry allowance.
+* the manager's `continuation` policy (`./continuation.ts`) re-enters the driver with Runtime's
+* continuation note, and every re-entry crosses the same budget, deadline, and abort bounds.
+* Successful continuations do not consume the failure retry allowance.
 *
 * This loop decides WHETHER to re-enter; it does not know WHERE the next drive runs. Whether the
 * re-entered driver continues the same harness session, the same environment, or a replacement is
 * the drive harness's fact, and the caller composes the re-entry task from it (see
-* `./reentry.ts`). A re-prompt re-enters the same session only on a backend that proves it.
+* `./reentry.ts`). A continuation re-enters the same session only on a backend that proves it.
 *
-* Progress bounds the re-prompts too. The same delivery reading that resets the barren failure
-* counter decides whether a re-prompted drive earned another: `reprompt.maxBarren` consecutive
-* re-entered drives that completed without a delivery end the loop with `repromptRefusedBy:
-* 'no-progress'`. Before this, a completed drive reset the barren counter and `decideReprompt`
-* read only the count cap, budget, and deadline, so a director with `repromptOnUnmet: 100` or
-* `'until-complete'` that delivered nothing was re-prompted until the budget or deadline ended it;
-* the old prompt-owned loop logged 896 of 1,011 rounds with no progress.
+* Progress bounds the continuations, and nothing else counts them. The same delivery reading that
+* resets the barren failure counter decides whether a continued drive earned another:
+* `continuation.maxBarren` consecutive re-entered drives that completed without progress end the
+* loop with `repromptRefusedBy: 'no-progress'`. Progress is a delivery or a rise in the check's
+* best composite. There is no count cap and no caller veto: the old prompt-owned loop logged 896
+* of 1,011 rounds with no progress, and 650 recorded inputs chose seven different re-prompt counts.
 *
 * A THIRD CLASS sits between the two: the upstream said "not now". A model provider's exhausted
 * quota, a rate limit, or an overloaded service (HTTP 429, 503, 529, or the router's own codes for
@@ -25561,28 +26493,8 @@ function unreportedSpend(total, prior) {
 * the router answered some turns in between (one lead spent 1.7M and 3.3M input tokens on two of
 * them) and each run's budget and 8-hour deadline were almost untouched.
 */
-/**
-* The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
-* `onUnmetContract`. It states the verdict, names what is owed, reports the ledger, and gives the
-* three steps — the same shape `depthStrategy` re-prompts a resumed session with, said in the
-* driver's own terms.
-*/
-function defaultUnmetContractSteer(context) {
-	const owed = context.describe?.trim();
-	return [
-		"The completion check has not passed. This run has delivered nothing yet.",
-		owed === void 0 || owed.length === 0 ? "The deliverable this run owes is still missing." : `The deliverable this run owes: ${owed}`,
-		`Workers settled: ${context.progress.settledCount}. Workers that passed the check: ${context.progress.deliveredCount ?? 0}.`,
-		"Do the unfinished work with the tools.",
-		"Verify that the check passes.",
-		"Then submit the result.",
-		"Do not restate work you already did."
-	].join("\n");
-}
 const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
 const DEFAULT_MAX_ATTEMPTS = 8;
-/** Two re-prompted drives in a row that deliver nothing end the re-prompts. */
-const DEFAULT_MAX_BARREN_REPROMPTS = 2;
 const DEFAULT_INITIAL_BACKOFF_MS = 2e3;
 const DEFAULT_MAX_BACKOFF_MS = 3e4;
 /**
@@ -25628,6 +26540,7 @@ var HarnessTurnFailedError = class extends Error {
 */
 function upstreamUnavailableSignal(error) {
 	if (!(error instanceof Error)) return void 0;
+	if (error instanceof CheckUnavailableError) return "check-unavailable";
 	if (error instanceof HarnessTurnFailedError) return unavailableSignalOfFailure({
 		error: error.message,
 		...error.errorCode === void 0 ? {} : { errorCode: error.errorCode }
@@ -25711,13 +26624,15 @@ function contractOf(mark) {
 /**
 * Did this attempt move the run toward its DELIVERABLE?
 *
-* A delivery always counts: an accepted submission, one more child that passed the check, or the
-* contract turning met. Spend and settlements count only while no declared check is outstanding —
-* with a check unmet they are the burn-rate reading this module's header measures and rejects.
+* A delivery always counts: an accepted submission, one more child that passed the check, the
+* contract turning met, or a rise in the check's best composite. Spend and settlements count only
+* while no declared check is outstanding — with a check unmet they are the burn-rate reading this
+* module's header measures and rejects.
 */
 function madeProgress(before, after) {
 	if (after.submitted && !before.submitted) return true;
 	if ((after.deliveredCount ?? 0) > (before.deliveredCount ?? 0)) return true;
+	if (after.composite !== void 0 && after.composite > (before.composite ?? -Infinity)) return true;
 	if (contractOf(before) !== "met" && contractOf(after) === "met") return true;
 	if (contractOf(after) === "unmet") return false;
 	return after.poolTokensSpent > before.poolTokensSpent || after.settledCount > before.settledCount;
@@ -25763,10 +26678,11 @@ async function defaultSleep(ms, signal) {
 /**
 * Run the driver until it completes WITH ITS CONTRACT MET, or until the budget, the deadline, an
 * abort, a terminal error, or a ceiling stops it. Transient failures are retried. A drive that
-* returns with its completion check unmet is re-entered on the same live session with the unmet
-* items, up to `reprompt.maxReprompts`. Throws `DriverAttemptsExhaustedError` (cause = the last
-* real failure) when a FAILURE ends the loop; a completed drive returns, met contract or not,
-* because deciding what an undelivered run is worth belongs to the finalizer, not to this loop.
+* returns with its completion check unmet is re-entered with Runtime's continuation note until the
+* continuation's deadline or `maxBarren` turns without progress. Throws
+* `DriverAttemptsExhaustedError` (cause = the last real failure) when a FAILURE ends the loop; a
+* completed drive returns, met contract or not, because deciding what an undelivered run is worth
+* belongs to the finalizer, not to this loop.
 */
 async function runDriverWithRetry(run) {
 	const now = run.now ?? Date.now;
@@ -25777,19 +26693,18 @@ async function runDriverWithRetry(run) {
 	const maxAttempts = Math.max(1, policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
 	const initialBackoff = Math.max(0, policy.initialBackoffMs ?? DEFAULT_INITIAL_BACKOFF_MS);
 	const maxBackoff = Math.max(initialBackoff, policy.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS);
-	const maxReprompts = run.reprompt?.maxReprompts ?? 0;
-	if (maxReprompts === "until-complete") {
-		const deadline = run.budget().deadlineMs;
-		if (!Number.isFinite(deadline) || deadline <= 0) throw new ValidationError$1("runDriverWithRetry: until-complete requires a finite positive deadline");
+	const continuation = run.continuation;
+	if (continuation !== void 0) {
+		if (!Number.isFinite(continuation.deadlineMs) || continuation.deadlineMs <= 0) throw new ValidationError$1("runDriverWithRetry: a continuation needs a finite positive deadline");
+		if (!Number.isInteger(continuation.maxBarren) || continuation.maxBarren < 1) throw new ValidationError$1("runDriverWithRetry: continuation.maxBarren must be an integer >= 1");
 	}
-	const maxBarren = Math.max(1, run.reprompt?.maxBarren ?? 2);
 	const attempts = [];
 	let consecutiveBarren = 0;
 	let barrenReentries = 0;
 	let failures = 0;
 	let consecutivePauses = 0;
 	let pauses = 0;
-	let reprompts = 0;
+	let continuations = 0;
 	let reentry;
 	const emit = async (record) => {
 		const entered = reentry === void 0 ? {} : { reentry: reentry.reason };
@@ -25801,32 +26716,33 @@ async function runDriverWithRetry(run) {
 		await run.onAttempt?.(stamped);
 	};
 	/**
-	* Decide what a completed-but-undelivered drive does next. Every bound the FAILURE path applies
-	* is applied here too — that is the fix for `budgetStop` having lived only in the catch arm — and
-	* the caller's hook is consulted last, so no hook can talk the loop past a deadline.
+	* Decide what a completed drive with its check unmet does next. Every bound the FAILURE path
+	* applies is applied here too — that is the fix for `budgetStop` having lived only in the catch
+	* arm — and they are read again after the note is composed, because composing may run the
+	* question panel.
 	*/
-	const decideReprompt = async (attempt, after) => {
-		if (maxReprompts !== "until-complete" && reprompts >= maxReprompts) return { refusedBy: "reprompts-exhausted" };
-		if (barrenReentries >= maxBarren) return { refusedBy: "no-progress" };
-		if (run.signal.aborted) return { refusedBy: "aborted" };
-		const byBudget = budgetStop(run.budget(), now());
-		if (byBudget === "deadline" || byBudget === "budget-exhausted") return { refusedBy: byBudget };
-		const context = {
+	const decideContinuation = async (policy, attempt, after) => {
+		const bounds = () => {
+			if (policy.closed()) return "closed";
+			if (run.signal.aborted) return "aborted";
+			if (now() >= policy.deadlineMs) return "deadline";
+			const byBudget = budgetStop(run.budget(), now());
+			return byBudget === "deadline" || byBudget === "budget-exhausted" ? byBudget : void 0;
+		};
+		if (barrenReentries >= policy.maxBarren) return { refusedBy: "no-progress" };
+		const before = bounds();
+		if (before !== void 0) return { refusedBy: before };
+		const steer = (await policy.compose({
 			attempt,
-			reprompts,
-			maxReprompts,
+			continuations,
 			progress: after,
 			budget: run.budget(),
-			...run.reprompt?.describe === void 0 ? {} : { describe: run.reprompt.describe },
-			barrenReentries
-		};
-		const decision = await run.reprompt?.onUnmetContract?.(context) ?? { steer: defaultUnmetContractSteer(context) };
-		if (decision === "stop") return { refusedBy: "caller-stop" };
-		if (run.signal.aborted) return { refusedBy: "aborted" };
-		const afterHook = budgetStop(run.budget(), now());
-		if (afterHook === "deadline" || afterHook === "budget-exhausted") return { refusedBy: afterHook };
-		const steer = typeof decision.steer === "string" ? decision.steer.trim() : "";
-		if (steer.length === 0) throw new ValidationError$1("runDriverWithRetry: onUnmetContract returned an empty steer — return a non-empty instruction or 'stop'");
+			barrenReentries,
+			signal: run.signal
+		})).trim();
+		const afterCompose = bounds();
+		if (afterCompose !== void 0) return { refusedBy: afterCompose };
+		if (steer.length === 0) throw new ValidationError$1("runDriverWithRetry: the continuation note is empty");
 		return { steer };
 	};
 	for (let attempt = 1;; attempt += 1) {
@@ -25940,10 +26856,10 @@ async function runDriverWithRetry(run) {
 		const contractField = contract === "none" ? {} : { contract };
 		if (progressed) barrenReentries = 0;
 		else if (reentry !== void 0 && contract === "unmet") barrenReentries += 1;
-		if (contract === "unmet" && (maxReprompts === "until-complete" || maxReprompts > 0)) {
-			const decision = await decideReprompt(attempt, after);
+		if (contract === "unmet" && continuation !== void 0) {
+			const decision = await decideContinuation(continuation, attempt, after);
 			if ("steer" in decision) {
-				reprompts += 1;
+				continuations += 1;
 				await emit({
 					attempt,
 					durationMs,
@@ -25955,7 +26871,7 @@ async function runDriverWithRetry(run) {
 				reentry = {
 					reason: "unmet-contract",
 					steer: decision.steer,
-					reprompt: reprompts
+					continuation: continuations
 				};
 				continue;
 			}
@@ -26083,8 +26999,9 @@ async function runFinalizer(finalizer, args) {
 		if (candidate === void 0) return false;
 		if (args.deliverable === void 0) return true;
 		try {
-			return await args.deliverable.check(candidate) === true;
+			return checkVerdictOf(await args.deliverable.check(candidate)).pass;
 		} catch (error) {
+			if (error instanceof CheckUnavailableError) throw error;
 			throw new ValidationError$1(`finalizer: parent completion check threw: ${error instanceof Error ? error.message : String(error)}`);
 		}
 	};
@@ -26349,10 +27266,10 @@ function createSupervisor() {
 				pool = createBudgetPool(opts.budget, runEpochMs, restored.poolRestore);
 			} else {
 				pool = createBudgetPool(opts.budget, runStartedAtMs);
-				await opts.journal.beginTree(opts.runId, runStartedAt);
+				if (existing === void 0) await opts.journal.beginTree(opts.runId, runStartedAt);
 				const rootReceipt = rootMaterializationReceipt(opts);
 				const rootRuntime = opts.rootMaterialization?.runtime ?? "inline";
-				await opts.journal.appendEvent(opts.runId, {
+				const rootEvents = [{
 					kind: "spawned",
 					id: opts.runId,
 					label: "root",
@@ -26362,14 +27279,15 @@ function createSupervisor() {
 					...opts.rootIdentity ? { identity: opts.rootIdentity } : {},
 					seq: 0,
 					at: runStartedAt
-				});
-				if (rootReceipt !== void 0) await opts.journal.appendEvent(opts.runId, {
+				}];
+				if (rootReceipt !== void 0) rootEvents.push({
 					kind: "materialized",
 					id: opts.runId,
 					receipt: rootReceipt,
 					seq: 0,
 					at: runStartedAt
 				});
+				await appendSpawnEvents(opts.journal, opts.runId, rootEvents);
 			}
 			const stableRootReceipt = resuming ? prior?.find((event) => event.kind === "materialized" && event.id === opts.runId)?.receipt : rootMaterializationReceipt(opts);
 			if (stableRootReceipt !== void 0) {
@@ -26501,6 +27419,7 @@ function createSupervisor() {
 						seq: teardownSeq++,
 						at: new Date(now()).toISOString()
 					});
+					if (releasing) await closeRetainedSlots(openScope);
 				} catch (error) {
 					if (actOutcome?.ok !== false) actOutcome = {
 						ok: false,
@@ -26706,11 +27625,18 @@ function createIntensityBreaker(opts, trip) {
 *  settlement either (it writes no `settled` record then), so `downCount` stays what it was:
 *  ordinary downs only; `fleetYield.down` is where a retained child is counted. */
 function wrapJournalForBreaker(journal, breaker) {
+	const recordDown = (ev) => {
+		if (ev.kind === "settled" && ev.status === "down" && ev.retainedExecution === void 0) breaker.recordDown(Date.parse(ev.at));
+	};
 	return {
 		loadTree: (root) => journal.loadTree(root),
 		beginTree: (root, at) => journal.beginTree(root, at),
+		...journal.appendEvents === void 0 ? {} : { appendEvents: (root, events) => {
+			for (const event of events) recordDown(event);
+			return journal.appendEvents?.(root, events) ?? Promise.resolve();
+		} },
 		appendEvent: (root, ev) => {
-			if (ev.kind === "settled" && ev.status === "down" && ev.retainedExecution === void 0) breaker.recordDown(Date.parse(ev.at));
+			recordDown(ev);
 			return journal.appendEvent(root, ev);
 		}
 	};
@@ -26917,13 +27843,16 @@ function fleetYieldFromForest(forest) {
 	const spawned = /* @__PURE__ */ new Set();
 	const terminal = /* @__PURE__ */ new Map();
 	const released = /* @__PURE__ */ new Set();
+	const unconfirmed = /* @__PURE__ */ new Set();
 	for (const { event } of forest.events) if (event.kind === "spawned") {
 		if (event.parent !== void 0) spawned.add(event.id);
 	} else if (event.kind === "settled" || event.kind === "cancelled") {
 		const bucket = event.kind === "cancelled" ? "cancelled" : event.status;
 		terminal.set(event.id, bucket);
-		if (event.retainedExecution === "released" && bucket !== "done") released.add(event.id);
-		else released.delete(event.id);
+		released.delete(event.id);
+		unconfirmed.delete(event.id);
+		if (bucket !== "done" && event.retainedExecution === "released") released.add(event.id);
+		if (bucket !== "done" && event.retainedExecution === "release-unconfirmed") unconfirmed.add(event.id);
 	}
 	const count = (bucket) => [...terminal.values()].filter((value) => value === bucket).length;
 	const fleetYield = {
@@ -26932,10 +27861,11 @@ function fleetYieldFromForest(forest) {
 		down: count("down"),
 		cancelled: count("cancelled"),
 		neverSettled: forest.inDoubt.length,
-		releasedUnrecovered: released.size
+		releasedUnrecovered: released.size,
+		releaseUnconfirmed: unconfirmed.size
 	};
 	if (fleetYield.done + fleetYield.down + fleetYield.cancelled + fleetYield.neverSettled !== fleetYield.spawned) throw new RuntimeRunStateError(`supervisor: fleet yield does not partition the spawned children of '${forest.root}' (${JSON.stringify(fleetYield)})`);
-	if (fleetYield.releasedUnrecovered > fleetYield.down + fleetYield.cancelled) throw new RuntimeRunStateError(`supervisor: released children exceed down + cancelled for '${forest.root}' (${JSON.stringify(fleetYield)})`);
+	if (fleetYield.releasedUnrecovered + fleetYield.releaseUnconfirmed > fleetYield.down + fleetYield.cancelled) throw new RuntimeRunStateError(`supervisor: released children exceed down + cancelled for '${forest.root}' (${JSON.stringify(fleetYield)})`);
 	return fleetYield;
 }
 /** The journaled nodes whose usage accounting is incomplete — one `SpendGap` per node+kind,
@@ -27000,6 +27930,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false || Object.values(s.resources ?? {}).some((resource) => resource.amount > 0 || !resource.known);
 }
 //#endregion
-export { interactiveAdmissionSeamKey as $, cloneSpend as $i, retainedCreateMaterial as $n, profileMaterializationAxes$1 as $r, readWorkerProgress as $t, restoreScopeOwnerAcceptedExecution as A, runtimeOwnedScopeOwnerRuntime as Ai, routerBrain as An, createRuntimeEventCollector as Ar, pendingWaits as At, bindScopeRetainedOwnerEnvironmentId as B, canonicalStreamEventFromSandboxEvent as Bi, sandboxClientAsProvider as Bn, DEFAULT_LOCAL_HARNESS as Br, createBudgetPool as Bt, beginScopeOwnerAttempt as C, promptOptionsFromAgentTurnInput as Ca, providerAttemptEvidence as Ci, isTerminalDecision as Cn, exportEvalRuns as Cr, FileResultBlobStore as Ct, meterRuntimeOwnedProviderAttempt as D, runtimeOwnedExecutorMaterialization as Di, acquireSandbox as Dn, padSpanId as Dr, insideCursorNamespace as Dt, meterRuntimeOwnedAccounting as E, runtimeOwnedExecutorExecutionBinding as Ei, probeSandboxCapabilities as En, loopEventToOtelSpan as Er, InMemorySpawnJournal as Et, isWaitOutcome as F, detachedFrozen as Fi, LEAF_CONTINUATION_TASK as Fn, runSettledCommand as Fr, parseWorkerToolTraceArtifact as Ft, scopeRetainedOwnerContext as G, mapSandboxEvent as Gi, sandboxSessionTraceSource as Gn, parseCodexTokenUsage as Gr, WORKER_TRACE_PROPAGATION as Gt, consumeScopeRetainedOwnerResult as H, createSandboxUsageLedger as Hi, unavailableSignalOfFailure as Hn, harnessInvocation as Hr, newUsageTotals as Ht, pollFor as I, detachedSnapshot as Ii, createAgentEnvironmentProviderRegistry as In, runWorktreeHarness as Ir, workerTraceAnalysisStore as It, scopeRetainedOwnerResult as J, sandboxEventServedBackend as Ji, errMessage as Jn, AGENT_PROFILE_MATERIALIZATION_AXES as Jr, workerTraceHeaders as Jt, scopeRetainedOwnerPriorSpend as K, mapSandboxToolEvent as Ki, registerRetainedExecutorPreparation as Kn, CodexExecutionDiagnosticError as Kr, readWorkerTraceContext as Kt, timerAt as L, projectSandboxOutcome as Li, providerAsExecutor as Ln, captureWorktreeDiff as Lr, BudgetReconcileFault as Lt, settledToIteration as M, unknownMaterializationReceipt as Mi, canonicalObservedModelParts as Mn, sanitizeAgentRuntimeEvent as Mr, WORKER_TOOL_TRACE_SCHEMA_VERSION as Mt, createWorkerSlots as N, executableAgentProfileSnapshot as Ni, observedModelMatchesDeclared as Nn, sanitizeKnowledgeReadinessReport as Nr, captureWorkerTraceEvidence as Nt, recordScopeOwnerMaterialization as O, runtimeOwnedExecutorProviderEvidence as Oi, assertBoxlessPromptOptions as On, padTraceId as Or, loadSpawnForest as Ot, createWaitProbes as P, executableAgentSpecSnapshot as Pi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Pn, sanitizeRuntimeStreamEvent as Pr, isTraceAnalysisStore as Pt, resolveSpawnResourcePaths as Q, chargedTokens as Qi, startRetainedRunInEnvironment as Qn, fullProfileMaterialization as Qr, createActivityLog as Qt, validateWaitSpec as R, readSandboxOutcome as Ri, providerAsSandboxClient as Rn, createWorktree as Rr, ReservationWaitRefused as Rt, assertRecursiveReservationPolicy as S, promptFromAgentTurnInput as Sa, newExecutionAttemptId as Si, defaultSelectWinner as Sn, createOtelExporter as Sr, createInPlaceCliExecutor as St, deriveNodeExecutionIdentity as T, runtimeOwnedDriveHarnessProviderEvidence as Ti, createSandboxLineage as Tn, generateSpanId as Tr, InMemoryResultBlobStore as Tt, prepareScopeRetainedOwnerTask as U, extractLlmCallEvent as Ui, createPushTraceSource as Un, harnessSupportsReasoningEffort as Ur, spendFromUsageEvents as Ut, bindScopeRetainedOwnerProvider as V, createSandboxToolPartState as Vi, unavailablePauseMs as Vn, LOCAL_HARNESSES as Vr, meterUsageEvent as Vt, reconcileScopeRetainedOwnerEnvironment as W, isSandboxTerminalEvent as Wi, decodeToolPart as Wn, localHarnessExecutable as Wr, spendFromUsageTotals as Wt, environmentReader as X, sumSandboxUsage as Xi, recoverRetainedRun as Xn, controlProfileMaterialization as Xr, taskToPrompt as Xt, SPAWN_RESOURCE_PATH_MAX_BYTES as Y, sandboxProgressEvents as Yi, reconnectRetainedRun as Yn, assertProfileMaterialization as Yr, workerTraceSeamKey as Yt, hostDirectoryReader as Z, addSpend as Zi, startRetainedRun as Zn, defineProfileMaterializationContract as Zr, DEFAULT_STALL_AFTER_MS as Zt, driverChild as _, awaitAbortable$1 as _a, authoredProfileDigest as _i, readCodexRolloutSession as _n, INTELLIGENCE_WIRE_VERSION as _r, createExecutorRegistry as _t, collectDelivered as a, sleep as aa, renderUnsupported as ai, createPeerMailbox as an, runAbortable as ar, workerInteractiveBindingsDir as at, withDriverExecutor as b, teardownExecutor as ba, knownExecutionBindingReceipt as bi, TERMINAL_DECISIONS as bn, buildRuntimeEventOtelSpans as br, DEFAULT_SANDBOX_STEERING_MAX_TURNS as bt, runTree as c, throwIfAborted as ca, validateProfileMaterialization as ci, peerMailVerbNames as cn, resolveRedactor as cr, startRetainedInteractiveRun as ct, HarnessTurnFailedError as d, zeroSpend as da, parseCommittedJsonLines as di, executorFailure as dn, persistHarnessTranscript as dr, rollingDispatch as dt, deleteBoxSafe as ea, promptControlProfileMaterialization as ei, createInbox as en, destroyInteractiveEnvironment as er, readWorkerInteractiveAdmissions as et, classifyDriverFailure as f, addResourceSpend as fa, prepareJsonlAppend as fi, bridgeAdmissionRefusal as fn, contentAddress as fr, bindReusableExecutorExecutionId as ft, upstreamUnavailableSignal as g, abortError$2 as ga, attestRuntimeOwnedScopeOwner as gi, harnessUsageIsEmpty as gn, traceContextToEnv as gr, createExecutor as gt, summarizeDriverAttempts as h, decodeHarnessUsage as ha, attestRuntimeOwnedPendingExecutor as hi, createCodexRolloutStoreReader as hn, readTraceContextFromEnv as hr, cliWorktreeExecutor as ht, bestDelivered as i, randomSuffix as ia, renderProfileMaterializationIssues as ii, claimsAuthority as in, linkAbort as ir, workerInteractiveBindingFile as it, scopeOwnerExecutorNodeContext as j, unknownExecutionBindingReceipt as ji, runBrainLoop as jn, createRuntimeStreamEventCollector as jr, replaySpawnTree as jt, recordScopeOwnerPause as k, runtimeOwnedPendingExecutorMaterialization as ki, readPromptOptions as kn, toOtelAttributes as kr, materializeTreeView as kt, DEFAULT_MAX_BARREN_REPROMPTS as l, unmeteredSpend as la, worktreeCliProfileMaterialization as li, isLiveNodeStatus as ln, captureHarnessTranscript as lr, freeSlots as lt, runDriverWithRetry as m, withBudgetResources as ma, writeAllBytes as mi, addHarnessUsage as mn, mergeTraceEnv as mr, cliInPlaceExecutor as mt, createRootHandle as n, isAbortError$2 as na, promptOnlyProfileMaterialization as ni, DEFAULT_PEER_MAIL_LIMITS as nn, RunCancellationReason as nr, attachWorker as nt, pickBestDelivered as o, stringifySafe as oa, sandboxActProfileMaterialization as oi, isPeerMailEnvelope as on, defaultRedactor as or, reconnectRetainedInteractiveRun as ot, defaultUnmetContractSteer as p, resourceTelemetry as pa, readCommittedJsonLines as pi, bridgeModelRouteRefusal as pn, createPropagatingTraceEmitter as pr, captureReusableExecutorConfig as pt, scopeRetainedOwnerResourceReader as q, notifySandboxEventObserver as qi, retainedExecutorSeamKey as qn, terminateProcessTreeAndConfirm as qr, workerTraceEnv as qt, createSupervisor as r, promptCacheTokenClasses as ra, promptResourceProfileMaterialization as ri, PEER_MAIL_WIRE_KEY as rn, abortError as rr, readWorkerInteractiveBinding as rt, runFinalizer as s, throwAbort as sa, unsupportedProfileDimensions as si, peerMailTools as sn, defaultRedactorIdentityMaterial as sr, recoverRetainedInteractiveRun as st, DEFAULT_MAX_DEPTH as t, hasCompleteCacheBreakdown as ta, promptModelProfileMaterialization as ti, AUTHORITY_MARKERS as tn, environmentGone as tr, workerInteractiveAdmissionFile as tt, DriverAttemptsExhaustedError as u, withTimeout as ua, isNoEntError as ui, isTerminalNodeStatus as un, harnessTranscriptArtifact as ur, queueOf as ut, driverExecutorFactory as v, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as va, finalizeRuntimeOwnedPendingExecutor as vi, bridgeRuntimeAttachmentsKey as vn, buildLoopOtelSpans as vr, snapshotExecutorConfig as vt, createScope as w, providerMessageText as wa, recordRuntimeOwnedDriveHarnessProviderEvidence as wi, runAgentRounds as wn, flatOtelSpan as wr, FileSpawnJournal as wt, SUBTREE_RESULT_LIMIT as x, teardownSurfaces as xa, knownMaterializationReceipt as xi, createSandboxForSpec as xn, createOpenInferenceFileExporter as xr, createSteerableSandboxSession as xt, isDriverSpec as y, armDeadlineTimer as ya, inheritRuntimeOwnedExecutorAttestation as yi, bridgeStopSignalKey as yn, buildLoopSpanNodes as yr, createWorktreeCliExecutor as yt, waitUntil as z, assertSandboxServedModel as zi, resolveAgentEnvironmentProvider as zn, removeWorktree as zr, assertValidBudget as zt };
+export { bindScopeRetainedOwnerProvider as $, detachedSnapshot as $i, providerAsExecutor as $n, runWorktreeHarness as $r, BudgetReconcileFault as $t, driverExecutorFactory as A, resourceTelemetry as Aa, readCommittedJsonLines as Ai, addHarnessUsage as An, createPropagatingTraceEmitter as Ar, snapshotExecutorConfig as At, recordScopeOwnerMaterialization as B, promptOptionsFromAgentTurnInput as Ba, providerAttemptEvidence as Bi, runAgentRounds as Bn, exportEvalRuns as Br, SpawnEventIndex as Bt, createContinuationKeeper as C, stringifySafe as Ca, sandboxActProfileMaterialization as Ci, peerMailTools as Cn, defaultRedactorIdentityMaterial as Cr, rollingDispatch as Ct, passedItems as D, withTimeout as Da, isNoEntError as Di, executorFailure as Dn, persistHarnessTranscript as Dr, cliWorktreeExecutor as Dt, failedItems as E, unmeteredSpend as Ea, worktreeCliProfileMaterialization as Ei, isTerminalNodeStatus as En, harnessTranscriptArtifact as Er, cliInPlaceExecutor as Et, beginScopeOwnerAttempt as F, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Fa, finalizeRuntimeOwnedPendingExecutor as Fi, bridgeStopSignalKey as Fn, buildLoopOtelSpans as Fr, createInPlaceCliExecutor as Ft, createWorkerSlots as G, runtimeOwnedExecutorProviderEvidence as Gi, readPromptOptions as Gn, padTraceId as Gr, materializeTreeView as Gt, restoreScopeOwnerAcceptedExecution as H, runtimeOwnedDriveHarnessProviderEvidence as Hi, probeSandboxCapabilities as Hn, generateSpanId as Hr, encodeResultBlob as Ht, createScope as I, armDeadlineTimer as Ia, inheritRuntimeOwnedExecutorAttestation as Ii, TERMINAL_DECISIONS as In, buildLoopSpanNodes as Ir, FileResultBlobStore as It, pollFor as J, unknownExecutionBindingReceipt as Ji, canonicalObservedModelParts as Jn, createRuntimeStreamEventCollector as Jr, WORKER_TOOL_TRACE_SCHEMA_VERSION as Jt, createWaitProbes as K, runtimeOwnedPendingExecutorMaterialization as Ki, routerBrain as Kn, toOtelAttributes as Kr, pendingWaits as Kt, deriveNodeExecutionIdentity as L, teardownExecutor as La, knownExecutionBindingReceipt as Li, createSandboxForSpec as Ln, buildRuntimeEventOtelSpans as Lr, FileSpawnJournal as Lt, withDriverExecutor as M, decodeHarnessUsage as Ma, attestRuntimeOwnedPendingExecutor as Mi, harnessUsageIsEmpty as Mn, readTraceContextFromEnv as Mr, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Mt, SUBTREE_RESULT_LIMIT as N, abortError$2 as Na, attestRuntimeOwnedScopeOwner as Ni, readCodexRolloutSession as Nn, traceContextToEnv as Nr, createSteerableSandboxSession as Nt, verdictFromJudgeScore as O, zeroSpend as Oa, parseCommittedJsonLines as Oi, bridgeAdmissionRefusal as On, readHarnessTranscript as Or, createExecutor as Ot, assertRecursiveReservationPolicy as P, awaitAbortable$1 as Pa, authoredProfileDigest as Pi, bridgeRuntimeAttachmentsKey as Pn, INTELLIGENCE_WIRE_VERSION as Pr, createRouterTranscript as Pt, bindScopeRetainedOwnerEnvironmentId as Q, detachedFrozen as Qi, createAgentEnvironmentProviderRegistry as Qn, runSettledCommand as Qr, workerTraceAnalysisStore as Qt, meterRuntimeOwnedAccounting as R, teardownSurfaces as Ra, knownMaterializationReceipt as Ri, defaultSelectWinner as Rn, createOpenInferenceFileExporter as Rr, InMemoryResultBlobStore as Rt, composeContinuationNote as S, sleep as Sa, renderUnsupported as Si, isPeerMailEnvelope as Sn, defaultRedactor as Sr, queueOf as St, expandQuestions as T, throwIfAborted as Ta, validateProfileMaterialization as Ti, isLiveNodeStatus as Tn, captureHarnessTranscript as Tr, captureReusableExecutorConfig as Tt, scopeOwnerExecutorNodeContext as U, runtimeOwnedExecutorExecutionBinding as Ui, acquireSandbox as Un, loopEventToOtelSpan as Ur, insideCursorNamespace as Ut, recordScopeOwnerPause as V, providerMessageText as Va, recordRuntimeOwnedDriveHarnessProviderEvidence as Vi, createSandboxLineage as Vn, flatOtelSpan as Vr, assertContentAddress as Vt, settledToIteration as W, runtimeOwnedExecutorMaterialization as Wi, assertBoxlessPromptOptions as Wn, padSpanId as Wr, loadSpawnForest as Wt, validateWaitSpec as X, executableAgentProfileSnapshot as Xi, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Xn, sanitizeKnowledgeReadinessReport as Xr, isTraceAnalysisStore as Xt, timerAt as Y, unknownMaterializationReceipt as Yi, observedModelMatchesDeclared as Yn, sanitizeAgentRuntimeEvent as Yr, captureWorkerTraceEvidence as Yt, waitUntil as Z, executableAgentSpecSnapshot as Zi, LEAF_CONTINUATION_TASK as Zn, sanitizeRuntimeStreamEvent as Zr, parseWorkerToolTraceArtifact as Zt, CheckUnavailableError as _, deleteBoxSafe as _a, promptControlProfileMaterialization as _i, AUTHORITY_MARKERS as _n, environmentGone as _r, workerInteractiveBindingsDir as _t, collectDelivered as a, createSandboxUsageLedger as aa, harnessInvocation as ai, spendFromUsageEvents as an, createPushTraceSource as ar, scopeRetainedOwnerResourceReader as at, bestComposite as b, promptCacheTokenClasses as ba, promptResourceProfileMaterialization as bi, claimsAuthority as bn, linkAbort as br, startRetainedInteractiveRun as bt, runTree as c, mapSandboxEvent as ca, parseCodexTokenUsage as ci, readWorkerTraceContext as cn, registerRetainedExecutorPreparation as cr, environmentReader as ct, classifyDriverFailure as d, sandboxEventServedBackend as da, AGENT_PROFILE_MATERIALIZATION_AXES as di, workerTraceSeamKey as dn, reconnectRetainedRun as dr, interactiveAdmissionSeamKey as dt, projectSandboxOutcome as ea, captureWorktreeDiff as ei, ReservationWaitRefused as en, providerAsSandboxClient as er, consumeScopeRetainedOwnerResult as et, runDriverWithRetry as f, sandboxProgressEvents as fa, assertProfileMaterialization as fi, taskToPrompt as fn, recoverRetainedRun as fr, readWorkerInteractiveAdmissions as ft, CONTINUATION_FACTS as g, cloneSpend as ga, profileMaterializationAxes$1 as gi, createInbox as gn, destroyInteractiveEnvironment as gr, workerInteractiveBindingFile as gt, CONTINUATIONS_DIR as h, chargedTokens as ha, fullProfileMaterialization as hi, readWorkerProgress as hn, retainedCreateMaterial as hr, readWorkerInteractiveBinding as ht, bestDelivered as i, createSandboxToolPartState as ia, LOCAL_HARNESSES as ii, newUsageTotals as in, unavailableSignalOfFailure as ir, scopeRetainedOwnerPriorSpend as it, isDriverSpec as j, withBudgetResources as ja, writeAllBytes as ji, createCodexRolloutStoreReader as jn, mergeTraceEnv as jr, createWorktreeCliExecutor as jt, driverChild as k, addResourceSpend as ka, prepareJsonlAppend as ki, bridgeModelRouteRefusal as kn, contentAddress as kr, createExecutorRegistry as kt, DriverAttemptsExhaustedError as l, mapSandboxToolEvent as la, CodexExecutionDiagnosticError as li, workerTraceEnv as ln, retainedExecutorSeamKey as lr, hostDirectoryReader as lt, upstreamUnavailableSignal as m, addSpend as ma, defineProfileMaterializationContract as mi, createActivityLog as mn, startRetainedRunInEnvironment as mr, attachWorker as mt, createRootHandle as n, assertSandboxServedModel as na, removeWorktree as ni, createBudgetPool as nn, sandboxClientAsProvider as nr, reconcileScopeRetainedOwnerEnvironment as nt, pickBestDelivered as o, extractLlmCallEvent as oa, harnessSupportsReasoningEffort as oi, spendFromUsageTotals as on, decodeToolPart as or, scopeRetainedOwnerResult as ot, summarizeDriverAttempts as p, sumSandboxUsage as pa, controlProfileMaterialization as pi, DEFAULT_STALL_AFTER_MS as pn, startRetainedRun as pr, workerInteractiveAdmissionFile as pt, isWaitOutcome as q, runtimeOwnedScopeOwnerRuntime as qi, runBrainLoop as qn, createRuntimeEventCollector as qr, replaySpawnTree as qt, createSupervisor as r, canonicalStreamEventFromSandboxEvent as ra, DEFAULT_LOCAL_HARNESS as ri, meterUsageEvent as rn, unavailablePauseMs as rr, scopeRetainedOwnerContext as rt, runFinalizer as s, isSandboxTerminalEvent as sa, localHarnessExecutable as si, WORKER_TRACE_PROPAGATION as sn, sandboxSessionTraceSource as sr, SPAWN_RESOURCE_PATH_MAX_BYTES as st, DEFAULT_MAX_DEPTH as t, readSandboxOutcome as ta, createWorktree as ti, assertValidBudget as tn, resolveAgentEnvironmentProvider as tr, prepareScopeRetainedOwnerTask as tt, HarnessTurnFailedError as u, notifySandboxEventObserver as ua, terminateProcessTreeAndConfirm as ui, workerTraceHeaders as un, errMessage as ur, resolveSpawnResourcePaths as ut, admitContinuationPolicy as v, hasCompleteCacheBreakdown as va, promptModelProfileMaterialization as vi, DEFAULT_PEER_MAIL_LIMITS as vn, RunCancellationReason as vr, reconnectRetainedInteractiveRun as vt, distillFindings as w, throwAbort as wa, unsupportedProfileDimensions as wi, peerMailVerbNames as wn, resolveRedactor as wr, bindReusableExecutorExecutionId as wt, checkVerdictOf as x, randomSuffix as xa, renderProfileMaterializationIssues as xi, createPeerMailbox as xn, runAbortable as xr, freeSlots as xt, admitFinding as y, isAbortError$2 as ya, promptOnlyProfileMaterialization as yi, PEER_MAIL_WIRE_KEY as yn, abortError as yr, recoverRetainedInteractiveRun as yt, meterRuntimeOwnedProviderAttempt as z, promptFromAgentTurnInput as za, newExecutionAttemptId as zi, isTerminalDecision as zn, createOtelExporter as zr, InMemorySpawnJournal as zt };
 
-//# sourceMappingURL=supervisor-B8UMAXya.js.map
+//# sourceMappingURL=supervisor-DdKPGluv.js.map