@tangle-network/agent-runtime 0.271.0 → 0.273.3

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

@@ -15,6 +15,7 @@ import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgent
 import { homedir, hostname, tmpdir } from "node:os";
 import { stripVTControlCharacters } from "node:util";
 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 } : {}
 		};
@@ -5491,9 +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}`;
-			attrs[ATTR.spanKind] = "TOOL";
+			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);
@@ -5559,7 +5568,8 @@ function buildLoopOtelSpans(events, traceId, rootParentSpanId) {
 		endTimeUnixNano: msToNs(node.endMs),
 		attributes: toOtelAttributes({
 			...node.attrs,
-			[ATTR.spanKind]: LOOP_SPAN_KIND[node.kind]
+			[ATTR.spanKind]: LOOP_SPAN_KIND[node.kind],
+			...node.parentSpanId === void 0 && rootParentSpanId ? { [ATTR.parentConfidence]: "explicit" } : {}
 		}),
 		status: { code: node.error ? 2 : 1 }
 	}));
@@ -5630,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) {
@@ -5661,6 +5676,7 @@ function buildLoopSpanNodes(events) {
 					attrs
 				};
 				currentRoundId = id;
+				roundIdByIndex.set(roundIdx, id);
 				break;
 			}
 			case "loop.iteration.started": {
@@ -5707,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);
@@ -5714,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":
@@ -6055,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"])
 });
@@ -6097,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
@@ -6157,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) {
@@ -6236,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,
@@ -6391,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;
@@ -9097,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);
 		}
@@ -9145,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,
@@ -16786,6 +16951,15 @@ function assertContentAddress(outRef, 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),
@@ -17886,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. */
@@ -18497,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;
@@ -18504,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 = {
@@ -18541,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,
@@ -18576,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"));
@@ -18676,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, {
@@ -18720,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)({
@@ -18756,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, {
@@ -21315,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));
@@ -23415,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, {
@@ -23567,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 } : {},
@@ -24227,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
@@ -25233,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({
@@ -25681,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.
@@ -25728,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
@@ -25755,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;
 /**
@@ -25822,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 }
@@ -25905,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;
@@ -25957,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;
@@ -25971,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 };
@@ -25995,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) {
@@ -26134,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,
@@ -26149,7 +26871,7 @@ async function runDriverWithRetry(run) {
 				reentry = {
 					reason: "unmet-contract",
 					steer: decision.steer,
-					reprompt: reprompts
+					continuation: continuations
 				};
 				continue;
 			}
@@ -26277,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)}`);
 		}
 	};
@@ -26543,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",
@@ -26556,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) {
@@ -26901,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);
 		}
 	};
@@ -27199,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 $, sumSandboxUsage as $i, recoverRetainedRun as $n, controlProfileMaterialization as $r, taskToPrompt as $t, restoreScopeOwnerAcceptedExecution as A, runtimeOwnedExecutorMaterialization as Ai, acquireSandbox as An, padSpanId as Ar, insideCursorNamespace as At, bindScopeRetainedOwnerEnvironmentId as B, projectSandboxOutcome as Bi, providerAsExecutor as Bn, captureWorktreeDiff as Br, BudgetReconcileFault as Bt, beginScopeOwnerAttempt as C, teardownExecutor as Ca, knownExecutionBindingReceipt as Ci, TERMINAL_DECISIONS as Cn, buildRuntimeEventOtelSpans as Cr, FileResultBlobStore as Ct, meterRuntimeOwnedProviderAttempt as D, providerMessageText as Da, recordRuntimeOwnedDriveHarnessProviderEvidence as Di, runAgentRounds as Dn, flatOtelSpan as Dr, SpawnEventIndex as Dt, meterRuntimeOwnedAccounting as E, promptOptionsFromAgentTurnInput as Ea, providerAttemptEvidence as Ei, isTerminalDecision as En, exportEvalRuns as Er, InMemorySpawnJournal as Et, isWaitOutcome as F, unknownMaterializationReceipt as Fi, canonicalObservedModelParts as Fn, sanitizeAgentRuntimeEvent as Fr, WORKER_TOOL_TRACE_SCHEMA_VERSION as Ft, scopeRetainedOwnerContext as G, createSandboxUsageLedger as Gi, unavailableSignalOfFailure as Gn, harnessInvocation as Gr, newUsageTotals as Gt, consumeScopeRetainedOwnerResult as H, assertSandboxServedModel as Hi, resolveAgentEnvironmentProvider as Hn, removeWorktree as Hr, assertValidBudget as Ht, pollFor as I, executableAgentProfileSnapshot as Ii, observedModelMatchesDeclared as In, sanitizeKnowledgeReadinessReport as Ir, captureWorkerTraceEvidence as It, scopeRetainedOwnerResult as J, mapSandboxEvent as Ji, sandboxSessionTraceSource as Jn, parseCodexTokenUsage as Jr, WORKER_TRACE_PROPAGATION as Jt, scopeRetainedOwnerPriorSpend as K, extractLlmCallEvent as Ki, createPushTraceSource as Kn, harnessSupportsReasoningEffort as Kr, spendFromUsageEvents as Kt, timerAt as L, executableAgentSpecSnapshot as Li, DEFAULT_SANDBOX_IDLE_TIMEOUT_SECONDS as Ln, sanitizeRuntimeStreamEvent as Lr, isTraceAnalysisStore as Lt, settledToIteration as M, runtimeOwnedPendingExecutorMaterialization as Mi, readPromptOptions as Mn, toOtelAttributes as Mr, materializeTreeView as Mt, createWorkerSlots as N, runtimeOwnedScopeOwnerRuntime as Ni, routerBrain as Nn, createRuntimeEventCollector as Nr, pendingWaits as Nt, recordScopeOwnerMaterialization as O, runtimeOwnedDriveHarnessProviderEvidence as Oi, createSandboxLineage as On, generateSpanId as Or, assertContentAddress as Ot, createWaitProbes as P, unknownExecutionBindingReceipt as Pi, runBrainLoop as Pn, createRuntimeStreamEventCollector as Pr, replaySpawnTree as Pt, resolveSpawnResourcePaths as Q, sandboxProgressEvents as Qi, reconnectRetainedRun as Qn, assertProfileMaterialization as Qr, workerTraceSeamKey as Qt, validateWaitSpec as R, detachedFrozen as Ri, LEAF_CONTINUATION_TASK as Rn, runSettledCommand as Rr, parseWorkerToolTraceArtifact as Rt, assertRecursiveReservationPolicy as S, armDeadlineTimer as Sa, inheritRuntimeOwnedExecutorAttestation as Si, bridgeStopSignalKey as Sn, buildLoopSpanNodes as Sr, createInPlaceCliExecutor as St, deriveNodeExecutionIdentity as T, promptFromAgentTurnInput as Ta, newExecutionAttemptId as Ti, defaultSelectWinner as Tn, createOtelExporter as Tr, InMemoryResultBlobStore as Tt, prepareScopeRetainedOwnerTask as U, canonicalStreamEventFromSandboxEvent as Ui, sandboxClientAsProvider as Un, DEFAULT_LOCAL_HARNESS as Ur, createBudgetPool as Ut, bindScopeRetainedOwnerProvider as V, readSandboxOutcome as Vi, providerAsSandboxClient as Vn, createWorktree as Vr, ReservationWaitRefused as Vt, reconcileScopeRetainedOwnerEnvironment as W, createSandboxToolPartState as Wi, unavailablePauseMs as Wn, LOCAL_HARNESSES as Wr, meterUsageEvent as Wt, environmentReader as X, notifySandboxEventObserver as Xi, retainedExecutorSeamKey as Xn, terminateProcessTreeAndConfirm as Xr, workerTraceEnv as Xt, SPAWN_RESOURCE_PATH_MAX_BYTES as Y, mapSandboxToolEvent as Yi, registerRetainedExecutorPreparation as Yn, CodexExecutionDiagnosticError as Yr, readWorkerTraceContext as Yt, hostDirectoryReader as Z, sandboxEventServedBackend as Zi, errMessage as Zn, AGENT_PROFILE_MATERIALIZATION_AXES as Zr, workerTraceHeaders as Zt, driverChild as _, withBudgetResources as _a, writeAllBytes as _i, addHarnessUsage as _n, mergeTraceEnv as _r, createExecutorRegistry as _t, collectDelivered as a, isAbortError$2 as aa, promptOnlyProfileMaterialization as ai, DEFAULT_PEER_MAIL_LIMITS as an, RunCancellationReason as ar, workerInteractiveBindingsDir as at, withDriverExecutor as b, awaitAbortable$1 as ba, authoredProfileDigest as bi, readCodexRolloutSession as bn, INTELLIGENCE_WIRE_VERSION as br, DEFAULT_SANDBOX_STEERING_MAX_TURNS as bt, runTree as c, sleep as ca, renderUnsupported as ci, createPeerMailbox as cn, runAbortable as cr, startRetainedInteractiveRun as ct, HarnessTurnFailedError as d, throwIfAborted as da, validateProfileMaterialization as di, peerMailVerbNames as dn, resolveRedactor as dr, rollingDispatch as dt, addSpend as ea, defineProfileMaterializationContract as ei, DEFAULT_STALL_AFTER_MS as en, startRetainedRun as er, readWorkerInteractiveAdmissions as et, classifyDriverFailure as f, unmeteredSpend as fa, worktreeCliProfileMaterialization as fi, isLiveNodeStatus as fn, captureHarnessTranscript as fr, bindReusableExecutorExecutionId as ft, upstreamUnavailableSignal as g, resourceTelemetry as ga, readCommittedJsonLines as gi, bridgeModelRouteRefusal as gn, createPropagatingTraceEmitter as gr, createExecutor as gt, summarizeDriverAttempts as h, addResourceSpend as ha, prepareJsonlAppend as hi, bridgeAdmissionRefusal as hn, contentAddress as hr, cliWorktreeExecutor as ht, bestDelivered as i, hasCompleteCacheBreakdown as ia, promptModelProfileMaterialization as ii, AUTHORITY_MARKERS as in, environmentGone as ir, workerInteractiveBindingFile as it, scopeOwnerExecutorNodeContext as j, runtimeOwnedExecutorProviderEvidence as ji, assertBoxlessPromptOptions as jn, padTraceId as jr, loadSpawnForest as jt, recordScopeOwnerPause as k, runtimeOwnedExecutorExecutionBinding as ki, probeSandboxCapabilities as kn, loopEventToOtelSpan as kr, encodeResultBlob as kt, DEFAULT_MAX_BARREN_REPROMPTS as l, stringifySafe as la, sandboxActProfileMaterialization as li, isPeerMailEnvelope as ln, defaultRedactor as lr, freeSlots as lt, runDriverWithRetry as m, zeroSpend as ma, parseCommittedJsonLines as mi, executorFailure as mn, persistHarnessTranscript as mr, cliInPlaceExecutor as mt, createRootHandle as n, cloneSpend as na, profileMaterializationAxes$1 as ni, readWorkerProgress as nn, retainedCreateMaterial as nr, attachWorker as nt, pickBestDelivered as o, promptCacheTokenClasses as oa, promptResourceProfileMaterialization as oi, PEER_MAIL_WIRE_KEY as on, abortError as or, reconnectRetainedInteractiveRun as ot, defaultUnmetContractSteer as p, withTimeout as pa, isNoEntError as pi, isTerminalNodeStatus as pn, harnessTranscriptArtifact as pr, captureReusableExecutorConfig as pt, scopeRetainedOwnerResourceReader as q, isSandboxTerminalEvent as qi, decodeToolPart as qn, localHarnessExecutable as qr, spendFromUsageTotals as qt, createSupervisor as r, deleteBoxSafe as ra, promptControlProfileMaterialization as ri, createInbox as rn, destroyInteractiveEnvironment as rr, readWorkerInteractiveBinding as rt, runFinalizer as s, randomSuffix as sa, renderProfileMaterializationIssues as si, claimsAuthority as sn, linkAbort as sr, recoverRetainedInteractiveRun as st, DEFAULT_MAX_DEPTH as t, chargedTokens as ta, fullProfileMaterialization as ti, createActivityLog as tn, startRetainedRunInEnvironment as tr, workerInteractiveAdmissionFile as tt, DriverAttemptsExhaustedError as u, throwAbort as ua, unsupportedProfileDimensions as ui, peerMailTools as un, defaultRedactorIdentityMaterial as ur, queueOf as ut, driverExecutorFactory as v, decodeHarnessUsage as va, attestRuntimeOwnedPendingExecutor as vi, createCodexRolloutStoreReader as vn, readTraceContextFromEnv as vr, snapshotExecutorConfig as vt, createScope as w, teardownSurfaces as wa, knownMaterializationReceipt as wi, createSandboxForSpec as wn, createOpenInferenceFileExporter as wr, FileSpawnJournal as wt, SUBTREE_RESULT_LIMIT as x, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as xa, finalizeRuntimeOwnedPendingExecutor as xi, bridgeRuntimeAttachmentsKey as xn, buildLoopOtelSpans as xr, createSteerableSandboxSession as xt, isDriverSpec as y, abortError$2 as ya, attestRuntimeOwnedScopeOwner as yi, harnessUsageIsEmpty as yn, traceContextToEnv as yr, createWorktreeCliExecutor as yt, waitUntil as z, detachedSnapshot as zi, createAgentEnvironmentProviderRegistry as zn, runWorktreeHarness as zr, workerTraceAnalysisStore 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-Cvd5mf7x.js.map
+//# sourceMappingURL=supervisor-DdKPGluv.js.map