@tangle-network/agent-runtime 0.192.5 → 0.194.0

package/dist/{redact-Ct7s2j86.js → redact-BOU77QfQ.js}

@@ -1,16 +1,13 @@
-import { A as assertEventBinding, B as exactContinuedControlRef, C as runtimeOwnedScopeOwnerRuntime, D as abortError, E as RetainedRunProviderContractError, F as assertWaitDuration, G as freezeControlRef, H as exactSession, I as awaitAbortable$1, J as sameControlCoordinates, K as hasDurableCancel, L as cancellationRequest, M as assertResultBinding, N as assertSequence, O as assertBoundaryBinding, P as assertStableText, R as copyControlRef, S as runtimeOwnedPendingExecutorMaterialization, T as unknownMaterializationReceipt, U as exactSessionCancel, V as exactControlRef, W as exactSessionResult, Y as freshTurnInput, _ as runtimeOwnedDeferredExecutorRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorMaterialization, c as knownExecutionBindingReceipt, g as recordRuntimeOwnedProviderModel, h as recordRuntimeOwnedProviderIdentityConflict, j as assertInteractionBinding, k as assertCanonicalEventBinding, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderDispatchNotStarted, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderAttemptStart, q as isTerminalSessionStatus, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, w as unknownExecutionBindingReceipt, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding, z as delay } from "./materialization-CekWK6OO.js";
+import { A as assertBoundaryBinding, B as copyControlRef, C as runtimeOwnedScopeOwnerRuntime, D as detachedSnapshot, F as assertSequence, G as exactSessionCancel, H as exactContinuedControlRef, I as assertStableText, J as hasDurableCancel, K as exactSessionResult, L as assertWaitDuration, M as assertEventBinding, N as assertInteractionBinding, O as RetainedRunProviderContractError, P as assertResultBinding, R as awaitAbortable$1, S as runtimeOwnedPendingExecutorMaterialization, T as unknownMaterializationReceipt, U as exactControlRef, V as delay, W as exactSession, X as sameControlCoordinates, Y as isTerminalSessionStatus, Z as freshTurnInput, _ as runtimeOwnedDeferredExecutorRuntime, a as authoredProfileDigest, b as runtimeOwnedExecutorMaterialization, c as knownExecutionBindingReceipt, g as recordRuntimeOwnedProviderModel, h as recordRuntimeOwnedProviderIdentityConflict, j as assertCanonicalEventBinding, k as abortError, l as knownMaterializationReceipt, m as recordRuntimeOwnedProviderDispatchNotStarted, n as attestRuntimeOwnedExecutor, o as finalizeRuntimeOwnedPendingExecutor, p as recordRuntimeOwnedProviderAttemptStart, q as freezeControlRef, r as attestRuntimeOwnedPendingExecutor, s as inheritRuntimeOwnedExecutorAttestation, t as attestRuntimeOwnedDeferredExecutor, u as newExecutionAttemptId, w as unknownExecutionBindingReceipt, x as runtimeOwnedExecutorProviderEvidence, y as runtimeOwnedExecutorExecutionBinding, z as cancellationRequest } from "./materialization-vZssF9Nx.js";
 import { c as RetainedInteractiveAdmissionError, d as RetainedRunDispatchBindingError, f as RuntimeRunStateError, l as RetainedInteractiveBindingError, m as ValidationError, r as BackendTransportError, u as RetainedRunAdmissionError } from "./errors-CDZ8XsVj.js";
-import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { _ as captureWorkerTraceEvidence, a as aggregateProviderModelEvidence, c as loadSpawnForest, d as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, l as materializeTreeView, m as nestedDriverTreeRoot, n as FileSpawnJournal, o as closesCursorSlot, p as driverRuntime, u as pendingWaits, x as contentAddress } from "./spawn-journal-B9eTmVAn.js";
-import { _ as throwIfAborted, a as cloneTokenUsage, b as zeroSpend, d as randomSuffix, f as randomUuid, g as throwAbort, h as stringifySafe, l as mapWithConcurrency, m as sleep, n as addTokenUsage, o as deleteBoxSafe, p as roundBoxMinutes, r as chargedTokens, s as hasCompleteCacheBreakdown, t as addSpend, u as promptCacheTokenClasses, v as unmeteredSpend, x as zeroTokenUsage, y as withTimeout } from "./util-mCNUeboW.js";
 import { _ as parseCodexUsageRecord, c as mapSandboxToolEvent, d as sandboxProgressEvents, h as parseCanonicalTransportEvent, i as createSandboxUsageLedger, l as notifySandboxEventObserver, m as extractTransportEventIdentity, r as createSandboxToolPartState, t as assertSandboxServedModel, u as sandboxEventServedBackend } from "./sandbox-events-DWeQRWxg.js";
-import { n as executableAgentSpecSnapshot, r as projectSandboxOutcome, t as executableAgentProfileSnapshot } from "./executable-spec-DxuiDFAU.js";
+import { a as executableAgentProfileSnapshot, i as writeAllBytes, n as parseCommittedJsonLines, o as executableAgentSpecSnapshot, r as prepareJsonlAppend, s as projectSandboxOutcome, t as isNoEntError } from "./jsonl-file-Bh1Q9nt0.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, d as agentHarness, l as profileProviderModel, o as enforceTokenLimits, s as profileBridgeWireModel, t as assertExecutableAgentProfile, u as resolveRouterRetryPolicy } from "./model-policy-Wf2MxXJ9.js";
-import { c as linkAbort, i as resolveAgentEnvironmentProvider, l as runAbortable, n as providerAsExecutor, r as providerAsSandboxClient, s as abortError$1 } from "./environment-provider-DEwsolvi.js";
+import { A as runAbortable, C as throwIfAborted, D as zeroTokenUsage, E as zeroSpend, O as abortError$1, S as throwAbort, T as withTimeout, _ as randomSuffix, b as sleep, c as addTokenUsage, d as cloneTokenUsage, f as deleteBoxSafe, g as promptCacheTokenClasses, h as mapWithConcurrency, i as resolveAgentEnvironmentProvider, k as linkAbort, l as chargedTokens, n as providerAsExecutor, p as hasCompleteCacheBreakdown, r as providerAsSandboxClient, s as addSpend, u as cloneSpend, v as randomUuid, w as unmeteredSpend, x as stringifySafe, y as roundBoxMinutes } from "./environment-provider-Dr-wfnHg.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { n as assertNoSymlinkDescendant, r as publishExclusiveDurableFile } from "./durable-file-D24y9zg7.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStatusSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, ContextTransferRequestSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, REASONING_EFFORTS, RuntimeEventEnvelopeSchema, TerminalReplayWindowSchema, TerminalSessionRefSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, exactAgentInteractiveSessionStart, harnessTypeSchema, nativeContextContinuationTurnDigest, nativeReasoningControl, profileMaterializationAxes, profileMaterializationAxes as profileMaterializationAxes$1, renderInputPartsAsText, sha256DigestSchema } from "@tangle-network/agent-interface";
-import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
+import { estimateCost, isModelPriced, isToolSpan, toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { appendFileSync, constants, createReadStream, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, readdir, realpath, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
@@ -649,7 +646,6 @@ function harnessProfileModel(harness, profile) {
 	if (provider !== nativeProvider) throw new Error(`harnessInvocation: ${harness} cannot materialize model provider ${JSON.stringify(provider)}; expected ${nativeProvider}`);
 	return model;
 }
-const DEFAULT_TIMEOUT_MS = 300 * 1e3;
 const DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
 const processKillGraceMs = 250;
 const processGroupExitConfirmMs = 1e3;
@@ -713,7 +709,7 @@ async function runLocalHarness(options) {
 	if (options.codexReproducible && harness !== "codex") throw new Error("runLocalHarness: codexReproducible requires the Codex harness");
 	if (options.codexReproducible && !isSupportedCodexPlatform()) throw new Error(`runLocalHarness: codexReproducible does not support ${process.platform}/${process.arch}; supported: linux and darwin on x64 or arm64`);
 	if (options.codexReadDeniedPaths !== void 0 && !options.codexReproducible) throw new Error("runLocalHarness: codexReadDeniedPaths requires codexReproducible");
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const timeoutMs = options.timeoutMs;
 	const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
 	if (!Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 0) throw new Error("runLocalHarness: maxOutputBytes must be a non-negative safe integer");
 	const spawnImpl = options.spawn ?? spawn;
@@ -812,7 +808,7 @@ async function runLocalHarness(options) {
 				}
 				return termination;
 			};
-			timer = timeoutMs > 0 ? setTimeout(() => {
+			timer = timeoutMs !== void 0 && timeoutMs > 0 ? setTimeout(() => {
 				timedOut = true;
 				terminate();
 			}, timeoutMs) : null;
@@ -6018,6 +6014,996 @@ function priceUnreceiptedWork(work) {
 	};
 }
 //#endregion
+//#region src/durable/content-address.ts
+/** Stable content address shared by result and trace artifacts. */
+function contentAddress(artifact) {
+	return `sha256:${createHash("sha256").update(stableStringify(artifact), "utf-8").digest("hex")}`;
+}
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+}
+//#endregion
+//#region src/runtime/supervise/trace-evidence.ts
+/**
+* Durable structured tool evidence for supervised workers.
+*
+* The executor-owned `TraceSource` is collected before teardown, snapshotted into the shared
+* content-addressed blob store, and only then referenced by a settlement. Analysis reconstructs
+* agent-eval's bounded `TraceAnalysisStore` from those exact bytes. Worker output is never accepted
+* as a substitute for tool evidence.
+*
+* @experimental
+*/
+/** Schema version for content-addressed worker tool-trace artifacts. */
+const WORKER_TOOL_TRACE_SCHEMA_VERSION = 1;
+/** Structural guard for the official bounded trace-analysis read contract. */
+function isTraceAnalysisStore(value) {
+	if (value === null || typeof value !== "object") return false;
+	const store = value;
+	return typeof store.getOverview === "function" && typeof store.queryTraces === "function" && typeof store.countTraces === "function" && typeof store.viewTrace === "function" && typeof store.viewSpans === "function" && typeof store.searchTrace === "function" && typeof store.searchSpan === "function";
+}
+/** Collect and persist one executor's structured tool trace without changing its task outcome. */
+async function captureWorkerTraceEvidence(readSource, blobs, executed) {
+	if (!executed) return unavailable$1("execution-did-not-start");
+	if (readSource === void 0) return unavailable$1("executor-did-not-expose-trace-source");
+	let source;
+	try {
+		source = readSource();
+	} catch {
+		return unavailable$1("trace-source-unavailable");
+	}
+	if (source === void 0) return unavailable$1("trace-source-unavailable");
+	let collected;
+	try {
+		collected = await source.collect();
+	} catch {
+		return unavailable$1("trace-collection-failed");
+	}
+	if (!Array.isArray(collected) || collected.some((span) => !isToolSpanValue(span))) return unavailable$1("invalid-tool-spans");
+	if (collected.length === 0) return unavailable$1("no-tool-spans-captured");
+	let artifact;
+	let traceRef;
+	try {
+		const snapshot = structuredClone(collected);
+		toolSpansToTraceAnalysisStore(snapshot);
+		artifact = {
+			schemaVersion: 1,
+			spans: snapshot
+		};
+		traceRef = contentAddress(artifact);
+	} catch {
+		return unavailable$1("invalid-tool-spans");
+	}
+	try {
+		await blobs.put(traceRef, artifact);
+	} catch {
+		return unavailable$1("trace-persistence-failed");
+	}
+	return Object.freeze({
+		status: "available",
+		traceRef,
+		spanCount: artifact.spans.length
+	});
+}
+/** Rehydrate exact persisted spans through agent-eval's one bounded trace-analysis adapter. */
+async function workerTraceAnalysisStore(evidence, blobs) {
+	if (evidence.status === "unavailable") return toolSpansToTraceAnalysisStore(void 0);
+	const raw = await blobs.get(evidence.traceRef);
+	if (raw === void 0) throw new ValidationError(`worker trace blob '${evidence.traceRef}' is missing; the settlement evidence is incomplete`);
+	const artifact = parseWorkerToolTraceArtifact(raw, evidence.traceRef);
+	if (artifact.spans.length !== evidence.spanCount) throw new ValidationError(`worker trace blob '${evidence.traceRef}' has ${artifact.spans.length} spans but its settlement records ${evidence.spanCount}`);
+	return toolSpansToTraceAnalysisStore(artifact.spans);
+}
+/** Validate a stored trace artifact before an analyst or replay trusts it. */
+function parseWorkerToolTraceArtifact(value, traceRef = "<unknown>") {
+	if (value === null || typeof value !== "object" || value.schemaVersion !== 1 || !Array.isArray(value.spans)) throw new ValidationError(`worker trace blob '${traceRef}' is not a version-1 tool trace artifact`);
+	const spans = value.spans;
+	if (spans.length === 0) return {
+		schemaVersion: 1,
+		spans
+	};
+	if (spans.some((span) => !isToolSpanValue(span))) throw new ValidationError(`worker trace blob '${traceRef}' contains a non-tool span`);
+	return {
+		schemaVersion: 1,
+		spans
+	};
+}
+function unavailable$1(reason) {
+	return Object.freeze({
+		status: "unavailable",
+		reason
+	});
+}
+function isToolSpanValue(value) {
+	try {
+		return isToolSpan(value);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/runtime/supervise/tree-key.ts
+/** Runtime tag used only for a child that owns another supervised scope. */
+const driverRuntime = "driver";
+const nestedDriverTreeOwners = /* @__PURE__ */ new WeakSet();
+/** Canonical journal key for the scope owned by one nested driver node. */
+function nestedDriverTreeRoot(parentTreeRoot, driverNodeId) {
+	return `${parentTreeRoot}/${driverNodeId}`;
+}
+/** Privately mark the exact recursive executor that will create a nested journal tree. */
+function attestNestedDriverTreeOwner(owner) {
+	nestedDriverTreeOwners.add(owner);
+	return owner;
+}
+/** Return the canonical owned tree only for an exact privately marked recursive executor. */
+function runtimeOwnedNestedDriverTreeRoot(owner, parentTreeRoot, driverNodeId) {
+	return nestedDriverTreeOwners.has(owner) ? nestedDriverTreeRoot(parentTreeRoot, driverNodeId) : void 0;
+}
+//#endregion
+//#region src/durable/spawn-journal.ts
+/**
+*
+* Event-sourced spawn journal for the recursive execution atom (build steps 3 + 7).
+*
+* The supervision tree is journaled as an append-only event log: every `spawned`,
+* `settled`, and `cancelled` is recorded AFTER it is observed-committed (never
+* speculative), mirroring `ConversationJournal`'s begin/append/load shape. The log
+* holds only the THIN decision record — ids, parentage, budget, the spend a decision
+* consumed, and a content-addressed `outRef`. The payloads the driver branched on
+* (the `out` artifacts) live in a separate `ResultBlobStore`, keyed by `outRef`, so
+* the journal stays small (decisions) and replay rehydrates the exact `Settled` from
+* the blob store (evidence). This is the decision/payload split the replay argument
+* rests on (B1/B2).
+*
+* Replay determinism (B2): `seq` is the monotonic cursor order `scope.next()` yielded
+* each settlement — NOT wall-clock. `replaySpawnTree` sorts strictly by `seq` before
+* touching the blob store, so the order in which rehydration `get`s resolve can never
+* reorder the replayed `Settled[]`; the result is identical regardless of blob latency.
+*
+* @stable
+*/
+/**
+* Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a
+* stable JSON encoding. Producers call this to derive the `outRef` they journal and
+* `put`; the FS/in-mem stores re-derive it on `put` to verify the supplied ref
+* matches (fail loud on a mismatch — a forged ref breaks the replay invariant).
+*
+* Stable encoding: object keys are sorted recursively so two structurally-equal
+* artifacts hash identically regardless of key insertion order.
+*/
+/**
+* In-memory `ResultBlobStore`. Content-addressed: `put` verifies the supplied
+* `outRef` matches the artifact's hash so a stale/forged ref fails loud rather than
+* silently rehydrating the wrong payload. Idempotent on an identical re-put.
+*
+* @stable
+*/
+var InMemoryResultBlobStore = class {
+	blobs = /* @__PURE__ */ new Map();
+	async put(outRef, artifact) {
+		assertContentAddress(outRef, artifact);
+		this.blobs.set(outRef, artifact);
+	}
+	async get(outRef) {
+		return this.blobs.has(outRef) ? this.blobs.get(outRef) : void 0;
+	}
+};
+/**
+* FS `ResultBlobStore`. One JSON file per artifact under `dir`, named by a
+* filesystem-safe encoding of the `outRef` (`sha256:<hex>` → `sha256-<hex>.json`).
+* `put` fsyncs so a crash between writes never loses an acknowledged blob.
+*
+* @stable
+*/
+var FileResultBlobStore = class {
+	dir;
+	constructor(dir) {
+		this.dir = dir;
+	}
+	async put(outRef, artifact) {
+		assertContentAddress(outRef, artifact);
+		const fs = await import("node:fs/promises");
+		await fs.mkdir(this.dir, { recursive: true });
+		const fh = await fs.open(this.blobPath(outRef), "w");
+		try {
+			await fh.write(JSON.stringify(artifact));
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+	async get(outRef) {
+		const fs = await import("node:fs/promises");
+		let text;
+		try {
+			text = await fs.readFile(this.blobPath(outRef), "utf8");
+		} catch (err) {
+			if (isNoEntError(err)) return void 0;
+			throw err;
+		}
+		return JSON.parse(text);
+	}
+	blobPath(outRef) {
+		return `${this.dir}/${outRef.replace(/:/g, "-")}.json`;
+	}
+};
+function assertContentAddress(outRef, artifact) {
+	const expected = contentAddress(artifact);
+	if (outRef !== expected) throw new Error(`blob outRef '${outRef}' does not match the artifact content hash '${expected}'; a content-addressed store refuses a mismatched ref (breaks the replay invariant)`);
+}
+/**
+* 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),
+*  - a duplicate `seq` within a tree is a corrupted cursor (fail loud) — two
+*    settlements cannot share the cursor position replay orders by.
+*
+* @stable
+*/
+var InMemorySpawnJournal = class {
+	trees = /* @__PURE__ */ new Map();
+	async loadTree(root) {
+		const tree = this.trees.get(root);
+		if (!tree) return void 0;
+		return tree.events.map((ev) => ({ ...ev }));
+	}
+	async beginTree(root, at) {
+		const existing = this.trees.get(root);
+		if (existing) {
+			if (existing.begunAt !== at) throw new Error(`spawn tree '${root}' already begun at ${existing.begunAt}; refusing to overwrite with ${at}`);
+			return;
+		}
+		this.trees.set(root, {
+			begunAt: at,
+			events: []
+		});
+	}
+	async appendEvent(root, ev) {
+		const tree = this.trees.get(root);
+		if (!tree) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+		assertSeqUnique(root, tree.events, ev);
+		tree.events.push({ ...ev });
+	}
+};
+/**
+* JSONL on disk. One line per record: the first record is `begin`, subsequent records
+* are `event` envelopes wrapping a `SpawnEvent`. `loadTree` replays the whole file,
+* filtering by `root`, and applies the same begin-precedes-events + unique-seq
+* corruption guards as the in-memory impl. Each append fsyncs so a crash between
+* writes never loses an acknowledged event.
+*
+* @stable
+*/
+var FileSpawnJournal = class {
+	path;
+	appendTail = Promise.resolve();
+	constructor(path) {
+		this.path = path;
+	}
+	async loadTree(root) {
+		const fs = await import("node:fs/promises");
+		let text;
+		try {
+			text = await fs.readFile(this.path, "utf8");
+		} catch (err) {
+			if (isNoEntError(err)) return void 0;
+			throw err;
+		}
+		let begun = false;
+		const events = [];
+		for (const record of parseCommittedJsonLines(text, this.path)) {
+			if (record.root !== root) continue;
+			if (record.kind === "begin") begun = true;
+			else {
+				if (!begun) throw new Error(`spawn journal corrupted: event for tree '${root}' precedes its begin record`);
+				assertSeqUnique(root, events, record.event);
+				events.push(record.event);
+			}
+		}
+		return begun ? events : void 0;
+	}
+	async beginTree(root, at) {
+		const existing = await this.loadTreeBegin(root);
+		if (existing) {
+			if (existing !== at) throw new Error(`spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`);
+			return;
+		}
+		await this.appendRecord({
+			kind: "begin",
+			root,
+			at
+		});
+	}
+	async appendEvent(root, ev) {
+		const events = await this.loadTree(root);
+		if (events === void 0) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+		assertSeqUnique(root, events, ev);
+		await this.appendRecord({
+			kind: "event",
+			root,
+			event: ev
+		});
+	}
+	async loadTreeBegin(root) {
+		const fs = await import("node:fs/promises");
+		let text;
+		try {
+			text = await fs.readFile(this.path, "utf8");
+		} catch (err) {
+			if (isNoEntError(err)) return void 0;
+			throw err;
+		}
+		for (const record of parseCommittedJsonLines(text, this.path)) if (record.root === root && record.kind === "begin") return record.at;
+	}
+	async appendRecord(record) {
+		const append = this.appendTail.then(() => this.writeRecord(record));
+		this.appendTail = append.catch(() => void 0);
+		return append;
+	}
+	async writeRecord(record) {
+		const fs = await import("node:fs/promises");
+		const path = await import("node:path");
+		await fs.mkdir(path.dirname(this.path), { recursive: true });
+		const needsSeparator = await prepareJsonlAppend(this.path);
+		const fh = await fs.open(this.path, "a");
+		try {
+			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+};
+/**
+* Load every journal tree owned by one recursive supervision run and flatten its nodes/events.
+*
+* Nested driver tree keys are a Runtime implementation detail; callers should use this reader
+* instead of deriving or scanning keys themselves. The reader follows only the explicit
+* `ownedTreeRoot` written after Runtime privately attested a recursive executor; the open runtime
+* string `driver` is never treated as ownership. Legacy records without `ownedTreeRoot` are
+* intentionally treated as leaves rather than guessing or scanning convention-derived keys.
+* This preserves each tree's independent cursor namespace on flattened events.
+* A driver whose subtree was never begun is reported in `missingTrees`; any spawned non-root node
+* without a terminal record is reported in `inDoubt`, matching resume's conservative lost-work
+* interpretation.
+*
+* This is a cold/quiescent reader, not a transaction across an actively mutating file. Every value
+* returned is a detached immutable snapshot, so later journal writes or caller mutation cannot
+* change the result already observed.
+*/
+async function loadSpawnForest(journal, root) {
+	const rootEvents = await journal.loadTree(root);
+	if (rootEvents === void 0) throw new Error(`loadSpawnForest: no journaled tree for root '${root}'`);
+	const trees = [];
+	const nodes = [];
+	const events = [];
+	const inDoubt = [];
+	const missingTrees = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [{
+		root,
+		events: rootEvents
+	}];
+	for (let cursor = 0; cursor < queue.length; cursor += 1) {
+		const current = queue[cursor];
+		if (visited.has(current.root)) throw new Error(`loadSpawnForest: recursive journal tree '${current.root}' was reached twice`);
+		visited.add(current.root);
+		const stableEvents = detachedSnapshot(current.events, `loadSpawnForest tree ${JSON.stringify(current.root)}`);
+		const view = detachedSnapshot(materializeTreeView(current.ownerSpawn === void 0 || stableEvents.some((event) => event.kind === "spawned" && event.id === current.ownerSpawn?.id) ? [...stableEvents] : [ownedTreeRootSpawn(current.ownerSpawn), ...stableEvents]), `loadSpawnForest view ${JSON.stringify(current.root)}`);
+		trees.push({
+			root: current.root,
+			...current.ownerNodeId === void 0 ? {} : { ownerNodeId: current.ownerNodeId },
+			...current.parentTreeRoot === void 0 ? {} : { parentTreeRoot: current.parentTreeRoot },
+			events: stableEvents,
+			view
+		});
+		nodes.push(...view.nodes.filter((node) => current.ownerNodeId === void 0 || node.id !== current.ownerNodeId).map((node) => ({
+			treeRoot: current.root,
+			...node
+		})));
+		events.push(...stableEvents.map((event) => ({
+			treeRoot: current.root,
+			event
+		})));
+		const terminal = /* @__PURE__ */ new Set();
+		for (const event of stableEvents) if (event.kind === "settled" || event.kind === "cancelled") terminal.add(event.id);
+		const spawns = stableEvents.filter((event) => event.kind === "spawned").sort((a, b) => a.seq - b.seq || a.id.localeCompare(b.id));
+		for (const spawn of spawns) {
+			if (spawn.parent !== void 0 && !terminal.has(spawn.id)) inDoubt.push({
+				treeRoot: current.root,
+				nodeId: spawn.id,
+				label: spawn.label,
+				runtime: spawn.runtime
+			});
+			if (spawn.ownedTreeRoot === void 0) continue;
+			const expectedRoot = nestedDriverTreeRoot(current.root, spawn.id);
+			if (spawn.ownedTreeRoot !== expectedRoot) throw new Error(`loadSpawnForest: node '${spawn.id}' owns non-canonical tree '${spawn.ownedTreeRoot}'; expected '${expectedRoot}'`);
+			const nestedRoot = spawn.ownedTreeRoot;
+			const nestedEvents = await journal.loadTree(nestedRoot);
+			if (nestedEvents === void 0) {
+				missingTrees.push({
+					parentTreeRoot: current.root,
+					ownerNodeId: spawn.id,
+					root: nestedRoot
+				});
+				continue;
+			}
+			queue.push({
+				root: nestedRoot,
+				events: nestedEvents,
+				ownerNodeId: spawn.id,
+				parentTreeRoot: current.root,
+				ownerSpawn: spawn
+			});
+		}
+	}
+	return detachedSnapshot({
+		root,
+		trees,
+		nodes,
+		events,
+		inDoubt,
+		missingTrees
+	}, "loadSpawnForest result");
+}
+/** Owned journal trees record the owner's turns and descendants, but the owner's spawn belongs to
+* the parent tree. Supply a view-only parentless copy so strict materialization can fold root
+* metering without weakening its missing-spawn corruption check for ordinary event lists. */
+function ownedTreeRootSpawn(spawn) {
+	const { parent: _parent, ownedTreeRoot: _ownedTreeRoot, ...root } = spawn;
+	return root;
+}
+/**
+* Aggregate provider-served model evidence across one recursively owned journal forest.
+*
+* The parent tree records an owned driver's terminal summary, while that driver's own inference
+* and descendants live in its owned tree. This reducer follows the forest reader's explicit tree
+* edges and consumes each tree's metered attempts plus terminal leaf settlements exactly once.
+* A summary node is skipped because its owned tree supplies the source records. Plan materialization
+* is intentionally not read: it proves only what Runtime requested, not what a provider served.
+*
+* Missing legacy evidence, an unfinished node, an unopened owned tree, an identity conflict, and a
+* paid attempt without a qualified served snapshot all return unknown. An explicit
+* `providerDispatch: "not_started"` arm and Runtime accounting-only metered records are ignored
+* for served-model identity, while absent or malformed legacy data remains unknown here.
+*/
+function aggregateProviderModelEvidence(forest) {
+	const attempts = [];
+	const observedModels = /* @__PURE__ */ new Set();
+	const canonicalModels = /* @__PURE__ */ new Set();
+	const nodes = /* @__PURE__ */ new Map();
+	let reason;
+	let sawProviderEvidence = false;
+	for (const node of forest.nodes) nodes.set(forestNodeKey(node.treeRoot, node.id), node);
+	if (forest.missingTrees.length > 0 || forest.inDoubt.length > 0) reason = "provider-model-missing";
+	const markMissing = () => {
+		reason ??= "provider-model-missing";
+	};
+	const markConflict = () => {
+		reason = "provider-model-conflict";
+	};
+	const append = (raw) => {
+		sawProviderEvidence = true;
+		if (!isProviderEvidenceObject(raw)) {
+			markMissing();
+			return;
+		}
+		if (raw.status === "unknown") {
+			if (raw.reason === "provider-model-conflict") markConflict();
+			else if (!hasOnlyNotStartedAttempts(raw)) markMissing();
+		} else if (raw.status !== "known") {
+			markMissing();
+			return;
+		}
+		if (!Array.isArray(raw.attempts) || !Array.isArray(raw.models)) {
+			markMissing();
+			return;
+		}
+		const declared = /* @__PURE__ */ new Set();
+		for (const model of raw.models) if (typeof model !== "string" || model.length === 0) markMissing();
+		else declared.add(model);
+		const observedInRecord = /* @__PURE__ */ new Set();
+		for (const rawAttempt of raw.attempts) {
+			if (!isProviderAttemptEvidence(rawAttempt)) {
+				markMissing();
+				continue;
+			}
+			if (rawAttempt.identityConflict === true) markConflict();
+			const observations = [...rawAttempt.observations];
+			if (rawAttempt.providerDispatch === "not_started") {
+				if (observations.length > 0) markMissing();
+				attempts.push(Object.freeze({
+					observations: Object.freeze([]),
+					providerDispatch: "not_started",
+					...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
+				}));
+				continue;
+			}
+			if (observations.length === 0) {
+				markMissing();
+				attempts.push(Object.freeze({
+					observations: Object.freeze([]),
+					...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
+				}));
+				continue;
+			}
+			let base;
+			let snapshot;
+			for (const model of observations) {
+				if (typeof model !== "string" || model.length === 0) {
+					markMissing();
+					continue;
+				}
+				observedInRecord.add(model);
+				observedModels.add(model);
+				const identity = servedIdentityParts(model);
+				if (identity === void 0) {
+					markMissing();
+					continue;
+				}
+				if (base !== void 0 && base !== identity.base) markConflict();
+				if (snapshot !== void 0 && identity.snapshot !== void 0 && snapshot !== identity.snapshot) markConflict();
+				base = identity.base;
+				snapshot ??= identity.snapshot;
+				if (identity.snapshot !== void 0) {
+					canonicalModels.add(`${identity.base}@${identity.snapshot}`);
+					if (canonicalModels.size > 1) markConflict();
+				}
+			}
+			if (base === void 0 || snapshot === void 0) markMissing();
+			attempts.push(Object.freeze({
+				observations: Object.freeze(observations),
+				...rawAttempt.identityConflict === true ? { identityConflict: true } : {}
+			}));
+		}
+		if (declared.size !== observedInRecord.size || [...declared].some((model) => !observedInRecord.has(model))) markMissing();
+	};
+	const terminal = (treeRoot, event) => {
+		const node = nodes.get(forestNodeKey(treeRoot, event.id));
+		if (node === void 0) {
+			markMissing();
+			return;
+		}
+		if (node.ownedTreeRoot !== void 0) return;
+		if (event.kind === "cancelled") {
+			markMissing();
+			return;
+		}
+		append(event.providerModel ?? node.providerModel);
+	};
+	for (const tree of forest.trees) for (const event of tree.events) if (event.kind === "metered") {
+		if (event.accountingOnly === true) {
+			if (event.providerModel !== void 0) markMissing();
+			continue;
+		}
+		if (nodes.get(forestNodeKey(tree.root, event.id))?.ownedTreeRoot !== void 0) continue;
+		const evidence = event.providerModel;
+		if (evidence === void 0) markMissing();
+		else append(evidence);
+	} else if (event.kind === "settled" || event.kind === "cancelled") terminal(tree.root, event);
+	if (!sawProviderEvidence || attempts.length === 0 || observedModels.size === 0) reason ??= "provider-model-missing";
+	const models = Object.freeze([...observedModels]);
+	const frozenAttempts = Object.freeze(attempts);
+	return Object.freeze(reason === void 0 ? {
+		status: "known",
+		attempts: frozenAttempts,
+		models
+	} : {
+		status: "unknown",
+		attempts: frozenAttempts,
+		models,
+		reason
+	});
+}
+function forestNodeKey(treeRoot, nodeId) {
+	return `${treeRoot}\u0000${nodeId}`;
+}
+function isProviderEvidenceObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "status" in value;
+}
+function hasOnlyNotStartedAttempts(evidence) {
+	return Array.isArray(evidence.attempts) && evidence.attempts.length > 0 && evidence.attempts.every((attempt) => isProviderAttemptEvidence(attempt) && attempt.providerDispatch === "not_started" && attempt.observations.length === 0 && attempt.identityConflict !== true);
+}
+function isProviderAttemptEvidence(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Array.isArray(value.observations) && (value.providerDispatch === void 0 || value.providerDispatch === "not_started");
+}
+function servedIdentityParts(model) {
+	const at = model.lastIndexOf("@");
+	const rawBase = at < 0 ? model : model.slice(0, at);
+	const base = rawBase.slice(rawBase.lastIndexOf("/") + 1);
+	if (base.length === 0) return void 0;
+	const snapshot = at < 0 ? void 0 : model.slice(at + 1);
+	if (snapshot !== void 0 && snapshot.length === 0) return void 0;
+	return snapshot === void 0 ? { base } : {
+		base,
+		snapshot
+	};
+}
+/**
+* Two `seq` namespaces share the journal: a `spawned` event's `seq` is the spawn ordinal
+* (the order children were created), and a `settled`/`cancelled` event's `seq` is the
+* monotonic CURSOR order `scope.next()` yielded that settlement (B2). The uniqueness
+* replay rests on is the cursor namespace — two settlements cannot share the position
+* replay orders by — so the guard checks only settled/cancelled events. A `spawned`
+* ordinal legitimately equals a later `settled` cursor seq and is not a collision.
+*/
+function assertSeqUnique(root, events, ev) {
+	if (ev.kind === "materialized") {
+		if (events.some((event) => event.kind === "materialized" && event.id === ev.id)) throw new Error(`spawn journal corrupted: duplicate materialization receipt for node '${ev.id}' in tree '${root}'`);
+		if (!events.some((event) => event.kind === "spawned" && event.id === ev.id)) throw new Error(`spawn journal corrupted: materialization for node '${ev.id}' precedes its spawn in tree '${root}'`);
+	}
+	if (ev.kind === "execution-bound") {
+		if (events.some((event) => event.kind === "execution-bound" && event.id === ev.id && event.binding.attemptId === ev.binding.attemptId)) throw new Error(`spawn journal corrupted: duplicate execution binding for node '${ev.id}' attempt '${ev.binding.attemptId}' in tree '${root}'`);
+		if (!events.some((event) => event.kind === "materialized" && event.id === ev.id)) throw new Error(`spawn journal corrupted: execution binding for node '${ev.id}' precedes materialization in tree '${root}'`);
+	}
+	if (outsideCursorNamespace(ev)) return;
+	if (events.some((e) => !outsideCursorNamespace(e) && e.seq === ev.seq)) throw new Error(`spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; the cursor order replay relies on is not unique`);
+}
+/**
+* The records that CLOSE a node's cursor slot: a settlement, a cancellation, or a wait being
+* woken. The complement question to {@link outsideCursorNamespace}, and the one a resume needs —
+* a kind missing here leaves a finished node looking live, so its budget is never reclaimed and
+* its reservation is replayed as still in doubt.
+*/
+function closesCursorSlot(ev) {
+	return ev.kind === "settled" || ev.kind === "cancelled" || ev.kind === "woken";
+}
+const outsideKinds = /* @__PURE__ */ new Set([
+	"spawned",
+	"waiting",
+	"metered",
+	"materialized",
+	"execution-bound",
+	"progress",
+	"edge",
+	"teardown-unconfirmed",
+	"trace-unpropagated",
+	"node-inputs-resolved",
+	"edge-verdict",
+	"join-state"
+]);
+/** True for a node-CREATION or informational record. Narrows, so a caller keeps the union's arms. */
+function outsideCursorNamespace(ev) {
+	return outsideKinds.has(ev.kind);
+}
+/** True for a record inside the cursor namespace. Narrows to {@link CursorNamespaceEvent}. */
+function insideCursorNamespace(ev) {
+	return !outsideKinds.has(ev.kind);
+}
+/**
+* Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled
+* child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly
+* as `scope.next()` originally delivered them.
+*
+* Determinism (B2): the events are sorted by `seq` BEFORE any blob `get`, so the
+* replay order is the recorded cursor order regardless of how fast each rehydration
+* resolves. `at` (wall-clock) is never a replay input. Fail loud on a tree that was
+* never begun, a settled-done event missing its `outRef`, or a blob the store can't
+* rehydrate — a silent gap would let `act` branch on the wrong evidence.
+*
+* @stable
+*/
+async function replaySpawnTree(journal, blobs, root) {
+	const events = await journal.loadTree(root);
+	if (events === void 0) throw new Error(`replaySpawnTree: no journaled tree for root '${root}'`);
+	const ordered = [...events].sort((a, b) => a.seq - b.seq);
+	const labels = /* @__PURE__ */ new Map();
+	const assignmentIds = /* @__PURE__ */ new Map();
+	const identities = /* @__PURE__ */ new Map();
+	const materializations = /* @__PURE__ */ new Map();
+	const executionBindings = /* @__PURE__ */ new Map();
+	for (const ev of ordered) {
+		if (ev.kind === "spawned" || ev.kind === "waiting") labels.set(ev.id, ev.label);
+		if (ev.kind === "spawned" && ev.assignmentId !== void 0) assignmentIds.set(ev.id, ev.assignmentId);
+		if (ev.kind === "spawned" && ev.identity !== void 0) identities.set(ev.id, copyFrozenIdentity(ev.identity));
+		if (ev.kind === "materialized") materializations.set(ev.id, ev.receipt);
+		if (ev.kind === "execution-bound") {
+			const bindings = executionBindings.get(ev.id) ?? [];
+			bindings.push(ev.binding);
+			executionBindings.set(ev.id, bindings);
+		}
+	}
+	const handleFor = (id, status) => replayHandle(id, labels.get(id) ?? id, status, {
+		assignmentId: assignmentIds.get(id),
+		identity: identities.get(id),
+		materialization: materializations.get(id),
+		executionBindings: executionBindings.get(id)
+	});
+	const settlementTime = (at) => {
+		const settledAt = Date.parse(at);
+		return Number.isFinite(settledAt) ? { settledAt } : {};
+	};
+	const settled = [];
+	for (const ev of ordered) {
+		if (ev.kind === "spawned") continue;
+		if (ev.kind === "waiting") continue;
+		if (ev.kind === "metered") continue;
+		if (ev.kind === "progress") continue;
+		if (ev.kind === "materialized") continue;
+		if (ev.kind === "execution-bound") continue;
+		if (ev.kind === "edge") continue;
+		if (ev.kind === "teardown-unconfirmed") continue;
+		if (ev.kind === "trace-unpropagated") continue;
+		if (ev.kind === "node-inputs-resolved") continue;
+		if (ev.kind === "edge-verdict") continue;
+		if (ev.kind === "join-state") continue;
+		if (ev.kind === "woken") {
+			if (ev.by === "cancelled" || ev.outRef === void 0) {
+				settled.push({
+					kind: "down",
+					handle: handleFor(ev.id, "cancelled"),
+					reason: "wait cancelled",
+					infra: false,
+					trace: {
+						status: "unavailable",
+						reason: "not-an-executor"
+					},
+					...settlementTime(ev.at),
+					seq: ev.seq
+				});
+				continue;
+			}
+			const outcome = await blobs.get(ev.outRef);
+			if (outcome === void 0) throw new Error(`replaySpawnTree: blob store has no wait outcome for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`);
+			settled.push({
+				kind: "done",
+				handle: handleFor(ev.id, "done"),
+				out: outcome,
+				outRef: ev.outRef,
+				spent: zeroSpend(),
+				trace: {
+					status: "unavailable",
+					reason: "not-an-executor"
+				},
+				...settlementTime(ev.at),
+				seq: ev.seq
+			});
+			continue;
+		}
+		if (ev.kind === "cancelled") {
+			settled.push({
+				kind: "down",
+				handle: handleFor(ev.id, "cancelled"),
+				reason: ev.reason,
+				infra: false,
+				trace: {
+					status: "unavailable",
+					reason: "execution-did-not-start"
+				},
+				...settlementTime(ev.at),
+				seq: ev.seq
+			});
+			continue;
+		}
+		if (ev.status === "down") {
+			const trace = traceEvidenceFor(ev);
+			if (trace.status === "available") await workerTraceAnalysisStore(trace, blobs);
+			settled.push({
+				kind: "down",
+				handle: handleFor(ev.id, "failed"),
+				reason: ev.reason ?? ev.verdict?.notes ?? "child down",
+				infra: ev.infra === true,
+				...ev.providerModel === void 0 ? {} : { providerModel: copyProviderModelEvidence(ev.providerModel) },
+				trace,
+				...settlementTime(ev.at),
+				seq: ev.seq
+			});
+			continue;
+		}
+		if (ev.outRef === void 0) throw new Error(`replaySpawnTree: settled-done event for '${ev.id}' (seq ${ev.seq}) has no outRef; cannot rehydrate the result the driver branched on`);
+		const out = await blobs.get(ev.outRef);
+		if (out === void 0) throw new Error(`replaySpawnTree: blob store has no artifact for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`);
+		const trace = traceEvidenceFor(ev);
+		if (trace.status === "available") await workerTraceAnalysisStore(trace, blobs);
+		settled.push({
+			kind: "done",
+			handle: handleFor(ev.id, "done"),
+			out,
+			outRef: ev.outRef,
+			verdict: ev.verdict,
+			spent: cloneSpend(ev.spent),
+			...ev.providerModel === void 0 ? {} : { providerModel: copyProviderModelEvidence(ev.providerModel) },
+			trace,
+			...settlementTime(ev.at),
+			seq: ev.seq
+		});
+	}
+	return settled;
+}
+function replayHandle(id, label, status, evidence = {}) {
+	return Object.freeze({
+		id,
+		label,
+		status,
+		...evidence.assignmentId === void 0 ? {} : { assignmentId: evidence.assignmentId },
+		...evidence.identity === void 0 ? {} : { identity: evidence.identity },
+		...evidence.materialization === void 0 ? {} : { materialization: evidence.materialization },
+		...evidence.executionBindings === void 0 ? {} : { executionBindings: Object.freeze([...evidence.executionBindings]) },
+		abort() {
+			throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`);
+		}
+	});
+}
+/** A replayed handle must not retain mutable references into the loaded journal event. */
+function copyFrozenIdentity(identity) {
+	const correlation = identity.correlation === void 0 ? void 0 : Object.freeze({ ...identity.correlation });
+	return Object.freeze({
+		...identity.profileDigest === void 0 ? {} : { profileDigest: identity.profileDigest },
+		...identity.taskDigest === void 0 ? {} : { taskDigest: identity.taskDigest },
+		...identity.candidateDigest === void 0 ? {} : { candidateDigest: identity.candidateDigest },
+		...correlation === void 0 ? {} : { correlation }
+	});
+}
+/**
+* Materialize a recorded `TreeView` from a journaled event list for inspection. Folds
+* `spawned`/`settled`/`cancelled` into a per-node snapshot in `seq` order, then adds each
+* `metered` event's driver-inference spend onto its node in a separate additive pass so the view
+* matches the recorded cursor. It does not recover live executors or driver state after restart.
+*/
+function materializeTreeView(events) {
+	const nodes = /* @__PURE__ */ new Map();
+	let root;
+	const spawns = events.filter((ev) => ev.kind === "spawned" || ev.kind === "waiting").sort((a, b) => a.seq - b.seq);
+	const settlements = events.filter((ev) => insideCursorNamespace(ev)).sort((a, b) => a.seq - b.seq);
+	for (const ev of spawns) {
+		if (ev.kind === "waiting") {
+			nodes.set(ev.id, {
+				id: ev.id,
+				parent: ev.parent,
+				label: ev.label,
+				status: "waiting",
+				runtime: "wait",
+				budget: {
+					maxIterations: 0,
+					maxTokens: 0
+				},
+				spent: zeroSpend()
+			});
+			continue;
+		}
+		if (ev.parent === void 0 && root === void 0) root = ev.id;
+		nodes.set(ev.id, {
+			id: ev.id,
+			parent: ev.parent,
+			label: ev.label,
+			status: "pending",
+			runtime: ev.runtime,
+			budget: ev.budget,
+			...ev.ownedTreeRoot === void 0 ? {} : { ownedTreeRoot: ev.ownedTreeRoot },
+			...ev.assignmentId === void 0 ? {} : { assignmentId: ev.assignmentId },
+			...ev.identity ? { identity: ev.identity } : {},
+			spent: zeroSpend()
+		});
+	}
+	for (const ev of settlements) if (ev.kind === "settled") {
+		const node = requireNode(nodes, ev.id);
+		node.status = ev.status === "done" ? "done" : "failed";
+		node.spent = cloneSpend(ev.spent);
+		node.providerModel = copyProviderModelEvidence(ev.providerModel);
+		node.outRef = ev.outRef;
+		node.trace = traceEvidenceFor(ev);
+		const settledAt = Date.parse(ev.at);
+		if (Number.isFinite(settledAt)) node.settledAt = settledAt;
+	} else if (ev.kind === "woken") {
+		const node = requireNode(nodes, ev.id);
+		node.status = ev.by === "cancelled" ? "cancelled" : "done";
+		node.outRef = ev.outRef;
+		node.trace = {
+			status: "unavailable",
+			reason: "not-an-executor"
+		};
+		const settledAt = Date.parse(ev.at);
+		if (Number.isFinite(settledAt)) node.settledAt = settledAt;
+	} else {
+		const node = requireNode(nodes, ev.id);
+		node.status = "cancelled";
+		node.trace = {
+			status: "unavailable",
+			reason: "execution-did-not-start"
+		};
+		const settledAt = Date.parse(ev.at);
+		if (Number.isFinite(settledAt)) node.settledAt = settledAt;
+	}
+	for (const ev of events) {
+		if (ev.kind !== "materialized") continue;
+		const node = requireNode(nodes, ev.id);
+		node.materialization = ev.receipt;
+		node.runtime = ev.receipt.runtime;
+	}
+	for (const ev of events) {
+		if (ev.kind !== "execution-bound") continue;
+		const node = requireNode(nodes, ev.id);
+		node.executionBindings ??= [];
+		node.executionBindings.push(ev.binding);
+	}
+	for (const ev of events) {
+		if (ev.kind !== "metered") continue;
+		const node = requireNode(nodes, ev.id);
+		node.spent = addSpend(node.spent, ev.spend);
+	}
+	const snapshots = [...nodes.values()].map(freezeSnapshot);
+	return {
+		root: root ?? snapshots[0]?.id ?? "",
+		nodes: snapshots,
+		inFlight: snapshots.filter((n) => n.status === "running" || n.status === "acquiring").length,
+		waiting: snapshots.filter((n) => n.status === "waiting").length
+	};
+}
+/**
+* The waits a journaled tree shows as ARMED but never woken — what a resumed run re-arms with the
+* ORIGINAL absolute deadline. Reading it from the journal (rather than from any live state) is
+* what makes "SIGKILL a waiting tree, a new process keeps waiting to the same instant" true.
+*/
+function pendingWaits(events) {
+	const woken = /* @__PURE__ */ new Set();
+	for (const ev of events) if (ev.kind === "woken") woken.add(ev.id);
+	const pending = [];
+	for (const ev of events) {
+		if (ev.kind !== "waiting" || woken.has(ev.id)) continue;
+		pending.push({
+			id: ev.id,
+			label: ev.label,
+			spec: ev.spec,
+			armedAt: ev.armedAt,
+			ordinal: ev.seq
+		});
+	}
+	return pending.sort((a, b) => a.ordinal - b.ordinal);
+}
+/** Copy provider evidence at the journal boundary so replay never exposes mutable event state. */
+function copyProviderModelEvidence(evidence) {
+	if (evidence === void 0) return void 0;
+	const attempts = Object.freeze(evidence.attempts.map((attempt) => Object.freeze({
+		observations: Object.freeze([...attempt.observations]),
+		...attempt.identityConflict ? { identityConflict: true } : {},
+		...attempt.providerDispatch === "not_started" ? { providerDispatch: "not_started" } : {}
+	})));
+	const models = Object.freeze([...evidence.models]);
+	return Object.freeze(evidence.status === "unknown" ? {
+		status: "unknown",
+		attempts,
+		models,
+		reason: evidence.reason
+	} : {
+		status: "known",
+		attempts,
+		models
+	});
+}
+function requireNode(nodes, id) {
+	const node = nodes.get(id);
+	if (!node) throw new Error(`spawn journal corrupted: settle/cancel for node '${id}' with no prior spawn`);
+	return node;
+}
+function freezeSnapshot(node) {
+	return {
+		id: node.id,
+		parent: node.parent,
+		label: node.label,
+		status: node.status,
+		runtime: node.runtime,
+		budget: node.budget,
+		ownedTreeRoot: node.ownedTreeRoot,
+		assignmentId: node.assignmentId,
+		identity: node.identity,
+		materialization: node.materialization,
+		executionBindings: node.executionBindings === void 0 ? void 0 : Object.freeze([...node.executionBindings]),
+		spent: node.spent,
+		providerModel: node.providerModel,
+		outRef: node.outRef,
+		trace: node.trace,
+		settledAt: node.settledAt
+	};
+}
+function traceEvidenceFor(event) {
+	return event.trace ?? {
+		status: "unavailable",
+		reason: "legacy-settlement-without-trace-evidence"
+	};
+}
+//#endregion
 //#region src/runtime/supervise/task-prompt.ts
 /**
 *
@@ -9010,10 +9996,14 @@ function scheduleBridgeRunStateRefresh(seam, activeRuns, observation) {
 /** One bridge GET over the `node:http(s)` core client — the same transport every other bridge
 *  read uses, so a computed provider endpoint never reaches global `fetch`. Resolves the status
 *  and the body text; a transport failure rejects. */
-function bridgeGet(seam, path, timeoutMs) {
+function bridgeGet(seam, path, timeoutMs, signal) {
 	const target = new URL(`${seam.bridgeUrl.replace(/\/$/, "")}${path}`);
 	const requestFn = target.protocol === "https:" ? request$1 : request;
 	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException(`bridge GET ${path} aborted before request`, "AbortError"));
+			return;
+		}
 		const req = requestFn(target, {
 			method: "GET",
 			headers: { authorization: `Bearer ${seam.bridgeBearer}` },
@@ -9028,8 +10018,14 @@ function bridgeGet(seam, path, timeoutMs) {
 				});
 			})().catch(reject);
 		});
+		const abort = () => req.destroy(new DOMException(`bridge GET ${path} aborted`, "AbortError"));
+		signal?.addEventListener("abort", abort, { once: true });
 		req.on("timeout", () => req.destroy(/* @__PURE__ */ new Error(`bridge GET ${path} timed out`)));
-		req.on("error", reject);
+		req.on("error", (error) => {
+			signal?.removeEventListener("abort", abort);
+			reject(error);
+		});
+		req.on("close", () => signal?.removeEventListener("abort", abort));
 		req.end();
 	});
 }
@@ -9038,30 +10034,44 @@ function bridgeGet(seam, path, timeoutMs) {
 *
 * The bridge answers exactly this question and 404s `no backend matches model "…"`, which is the
 * error a child would otherwise discover after it was spawned and metered. Returns `undefined`
-* when the route resolves; otherwise the operator-facing reason it did not. FAIL CLOSED: a
-* transport error and an unexpected status are both reasons, never a silent pass.
+* when the route resolves; otherwise it returns the reason and whether the failure can recover.
+* A transport error and an unexpected status never become a silent pass.
 */
-async function bridgeModelRouteRefusal(seam, wireModel) {
+async function bridgeModelRouteRefusal(seam, wireModel, signal) {
 	const base = seam.bridgeUrl.replace(/\/$/, "");
 	let answer;
 	try {
-		answer = await bridgeGet(seam, `/v1/capabilities?model=${encodeURIComponent(wireModel)}`, BRIDGE_RUN_STATE_TIMEOUT_MS);
+		answer = await bridgeGet(seam, `/v1/capabilities?model=${encodeURIComponent(wireModel)}`, BRIDGE_RUN_STATE_TIMEOUT_MS, signal);
 	} catch (error) {
-		return `bridge ${base} did not answer for model ${JSON.stringify(wireModel)}: ${error instanceof Error ? error.message : String(error)}`;
+		if (signal?.aborted) throw error;
+		return {
+			detail: `bridge ${base} did not answer for model ${JSON.stringify(wireModel)}: ${error instanceof Error ? error.message : String(error)}`,
+			retryable: true
+		};
 	}
 	if (answer.status === 200) return void 0;
-	return answer.status === 404 ? `bridge ${base} routes no backend for model ${JSON.stringify(wireModel)}` : `bridge ${base} answered ${answer.status} for model ${JSON.stringify(wireModel)}`;
+	if (answer.status === 404) return {
+		detail: `bridge ${base} routes no backend for model ${JSON.stringify(wireModel)}`,
+		retryable: false,
+		status: answer.status
+	};
+	return {
+		detail: `bridge ${base} answered ${answer.status} for model ${JSON.stringify(wireModel)}`,
+		retryable: answer.status === 408 || answer.status === 429 || answer.status >= 500,
+		status: answer.status
+	};
 }
 /**
-* `GET /health` → `admission.{active,maxActive}`, or `undefined` when the bridge does not report
-* them. ADVISORY by nature — admission fills and drains — so an unanswered or admission-less
-* `/health` is not evidence about capacity and must not be read as one.
+* Read the default bulk lane from `GET /health`. Runtime sends no reserved-client header, so
+* overall capacity can look free while the lane this request will use is already full. Older
+* bridges expose only the overall counters; those retain the prior fallback.
 */
-async function bridgeAdmissionRead(seam) {
+async function bridgeAdmissionRefusal(seam, signal) {
 	let answer;
 	try {
-		answer = await bridgeGet(seam, "/health", BRIDGE_RUN_STATE_TIMEOUT_MS);
-	} catch {
+		answer = await bridgeGet(seam, "/health", BRIDGE_RUN_STATE_TIMEOUT_MS, signal);
+	} catch (error) {
+		if (signal?.aborted) throw error;
 		return;
 	}
 	let parsed;
@@ -9073,11 +10083,15 @@ async function bridgeAdmissionRead(seam) {
 	const admission = parsed?.admission;
 	const active = admission?.active;
 	const maxActive = admission?.maxActive;
-	if (typeof active !== "number" || typeof maxActive !== "number" || maxActive <= 0) return;
-	return {
-		active,
-		maxActive
-	};
+	const bulkActive = admission?.activeByClass?.bulk;
+	const bulkMaxActive = admission?.bulkMaxActive;
+	if (typeof bulkActive === "number" && Number.isFinite(bulkActive) && bulkActive >= 0 && typeof bulkMaxActive === "number" && Number.isFinite(bulkMaxActive) && bulkMaxActive >= 0) {
+		if (bulkActive < bulkMaxActive) return void 0;
+		const total = typeof active === "number" && typeof maxActive === "number" ? ` (total active ${active} of maxActive ${maxActive})` : "";
+		return `bridge ${seam.bridgeUrl.replace(/\/$/, "")} bulk admission is full: active ${bulkActive} of bulkMaxActive ${bulkMaxActive}${total}`;
+	}
+	if (typeof active !== "number" || !Number.isFinite(active) || active < 0 || typeof maxActive !== "number" || !Number.isFinite(maxActive) || maxActive <= 0 || active < maxActive) return;
+	return `bridge ${seam.bridgeUrl.replace(/\/$/, "")} admission is full: active ${active} of maxActive ${maxActive}`;
 }
 /** `GET /v1/runs/:id` — the bridge's durable-run registry read. Resolves `undefined` for any
 *  non-200 or non-conforming body rather than throwing: this is only ever an observability read. */
@@ -9160,7 +10174,7 @@ async function* streamBridgeSession(args) {
 	};
 	if (harnessStore) await readHarnessStoreDelta(harnessStore, observation);
 	let nextPrompt = taskToPrompt(args.task);
-	for (let t = 0; args.maxTurns === 0 || t < args.maxTurns; t += 1) {
+	for (let t = 0; args.maxTurns === 0 || t < args.maxTurns;) {
 		if (args.stopSignal?.aborted) {
 			observation.note = "settled after completion request";
 			break;
@@ -9199,6 +10213,38 @@ async function* streamBridgeSession(args) {
 			external.removeEventListener("abort", abortTurn);
 			if (timer) clearTimeout(timer);
 		};
+		let initialModelCredential;
+		const preflightSignal = args.stopSignal === void 0 ? turnController.signal : AbortSignal.any([turnController.signal, args.stopSignal]);
+		try {
+			await assertBridgeExecutionCapabilities(seam, preflightSignal, args.runtimeAttachments !== void 0);
+			if (preflightSignal.aborted) throw new DOMException("bridgeExecutor: aborted before bridge dispatch", "AbortError");
+			initialModelCredential = await runAbortable(() => resolveBridgeModelCredential(seam.modelCredential, "bridgeExecutor"), preflightSignal, "bridgeExecutor: credential preflight aborted");
+			if (preflightSignal.aborted) throw new DOMException("bridgeExecutor: aborted before bridge dispatch", "AbortError");
+		} catch (error) {
+			if (args.stopSignal?.aborted) {
+				cleanup();
+				observation.note = "settled after completion request";
+				break;
+			}
+			const interruptedBeforeDispatch = interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted;
+			try {
+				args.onProviderAttemptStart();
+				args.onProviderDispatchNotStarted();
+			} finally {
+				cleanup();
+			}
+			if (interruptedBeforeDispatch) {
+				observation.note = `turn ${turns + 1} interrupted before dispatch, resuming`;
+				continue;
+			}
+			throw error;
+		}
+		if (args.stopSignal?.aborted) {
+			observation.note = "settled after completion request";
+			cleanup();
+			break;
+		}
+		args.onProviderAttemptStart();
 		const activeRun = {
 			id: `bridge-run-${randomUUID()}`,
 			transportAttempts: 0,
@@ -9240,17 +10286,12 @@ async function* streamBridgeSession(args) {
 			}
 		};
 		try {
-			if (args.stopSignal?.aborted) {
-				observation.note = "settled after completion request";
-				break;
-			}
-			args.onProviderAttemptStart();
 			for await (const chunk of streamDurableBridgeRun({
 				seam,
+				initialModelCredential,
 				profile: args.profile,
 				sessionId: args.sessionId,
 				body: requestBody,
-				requiresRuntimeAttachments: args.runtimeAttachments !== void 0,
 				signal: turnController.signal,
 				run: activeRun,
 				maxReconnects: args.maxReconnects,
@@ -9376,6 +10417,7 @@ async function* streamBridgeSession(args) {
 		}
 		if (interruptSig.aborted && !args.signal.aborted && !args.controller.signal.aborted) interrupted = true;
 		turns += 1;
+		t += 1;
 		observation.turns = turns;
 		observation.activity.push({
 			at: Date.now(),
@@ -9574,16 +10616,16 @@ const BRIDGE_BRUTAL_KILL_WAIT_MS = 150;
 * cannot prove continuity fails instead of returning a plausible partial answer.
 */
 async function* streamDurableBridgeRun(args) {
-	await assertBridgeExecutionCapabilities(args.seam, args.signal, args.requiresRuntimeAttachments);
 	let reconnects = 0;
 	let pendingUpstreamError;
 	for (;;) {
 		let res;
 		try {
+			const modelCredential = args.run.transportAttempts === 0 ? args.initialModelCredential : await runAbortable(() => resolveBridgeModelCredential(args.seam.modelCredential, "bridgeExecutor"), args.signal, "bridgeExecutor: reconnect credential lookup aborted");
 			args.run.transportAttempts += 1;
 			res = await bridgeStreamPost(args.seam.bridgeUrl, {
 				bearer: args.seam.bridgeBearer,
-				modelCredential: args.seam.modelCredential,
+				modelCredential,
 				sessionId: args.sessionId,
 				runId: args.run.id,
 				afterEventId: args.run.lastEventId,
@@ -9698,6 +10740,16 @@ async function assertBridgeExecutionCapabilities(seam, signal, requiresRuntimeAt
 		const attachments = body.capabilities?.runtimeAttachments;
 		if (attachments === null || typeof attachments !== "object" || attachments.mcp !== true) throw new ValidationError(`bridgeExecutor: bridge at ${seam.bridgeUrl} does not advertise capabilities.runtimeAttachments.mcp; upgrade cli-bridge to a version that carries Runtime MCP attachments outside the bound AgentProfile`);
 	}
+	const routeRefusal = await bridgeModelRouteRefusal(seam, seam.model, signal);
+	if (routeRefusal !== void 0) {
+		if (routeRefusal.retryable) throw new BackendTransportError("bridge", `bridgeExecutor: ${routeRefusal.detail}`, {
+			...routeRefusal.status === void 0 ? {} : { status: routeRefusal.status },
+			providerDispatch: "not_started"
+		});
+		throw new ValidationError(`bridgeExecutor: ${routeRefusal.detail}`);
+	}
+	const admissionRefusal = await bridgeAdmissionRefusal(seam, signal);
+	if (admissionRefusal !== void 0) throw new BackendTransportError("bridge", `bridgeExecutor: ${admissionRefusal}`, { providerDispatch: "not_started" });
 }
 /**
 * POST one streamed turn to the cli-bridge over the `node:http(s)` core client
@@ -9712,7 +10764,6 @@ async function assertBridgeExecutionCapabilities(seam, signal, requiresRuntimeAt
 * shared `parseSseChatStream` consumes it unchanged.
 */
 async function bridgeStreamPost(url, args) {
-	const modelCredential = await resolveBridgeModelCredential(args.modelCredential, "bridgeExecutor");
 	const target = new URL(`${url.replace(/\/$/, "")}/v1/chat/completions`);
 	const payload = JSON.stringify(args.body);
 	const requestFn = target.protocol === "https:" ? request$1 : request;
@@ -9727,9 +10778,9 @@ async function bridgeStreamPost(url, args) {
 				...args.traceHeaders,
 				"content-type": "application/json",
 				authorization: `Bearer ${args.bearer}`,
-				...modelCredential === void 0 ? {} : {
-					[bridgeModelCredentialHeader]: modelCredential.token,
-					[bridgeModelBaseUrlHeader]: modelCredential.baseUrl
+				...args.modelCredential === void 0 ? {} : {
+					[bridgeModelCredentialHeader]: args.modelCredential.token,
+					[bridgeModelBaseUrlHeader]: args.modelCredential.baseUrl
 				},
 				"x-session-id": args.sessionId,
 				"x-run-id": args.runId,
@@ -13633,6 +14684,10 @@ function createScope(args) {
 		};
 		if (opts.key !== void 0) {
 			const existing = keyed.get(opts.key);
+			if (existing?.state === "in-doubt") return {
+				ok: false,
+				reason: "in-doubt"
+			};
 			if (existing !== void 0) {
 				prepared = prepare();
 				if (!isCompleteIdentity(prepared.identity)) return {
@@ -13661,10 +14716,6 @@ function createScope(args) {
 				priorId: existing.id,
 				reason: existing.reason
 			};
-			else if (existing?.state === "in-doubt") prior = {
-				state: "lost",
-				priorId: existing.id
-			};
 		}
 		if (args.maxDepth !== void 0 && args.depth >= args.maxDepth) return {
 			ok: false,
@@ -13851,12 +14902,11 @@ function createScope(args) {
 				if (pending !== void 0) {
 					if (profileDigest === void 0) throw new ValidationError("scope.spawn: a pending materialization requires a canonical authored profile");
 					if (pending.runtime !== executor.runtime || pending.binding.attemptId !== attemptId) throw new ValidationError("scope.spawn: pending executor did not bind the kernel-minted attempt id");
-					const plannedReceipt = knownMaterializationReceipt({
+					if (knownMaterializationReceipt({
 						authoredProfileDigest: profileDigest,
 						runtime: executor.runtime,
 						declaration: pending.declaration
-					});
-					if (plannedReceipt.status !== "known" || plannedReceipt.effectiveProfileDigest !== plannedReceipt.authoredProfileDigest) throw new ValidationError("scope.spawn: pending executor changed the authored AgentProfile before execution");
+					}).status !== "known") throw new ValidationError("scope.spawn: pending executor returned an unknown receipt");
 					let recorded = false;
 					pendingEvidence = {
 						complete: async () => {
@@ -13870,7 +14920,6 @@ function createScope(args) {
 								declaration: acknowledged
 							});
 							if (finalReceipt.status !== "known") throw new ValidationError("scope.spawn: terminal materialization remained unknown");
-							if (finalReceipt.effectiveProfileDigest !== finalReceipt.authoredProfileDigest) throw new ValidationError("scope.spawn: external executor changed the authored AgentProfile");
 							const finalBinding = knownExecutionBindingReceipt(finalReceipt, acknowledgedBinding);
 							await appendNodeMaterialization(args, id, ordinal, finalReceipt, finalBinding, now);
 							live.materialization = finalReceipt;
@@ -14363,7 +15412,6 @@ async function recordScopeOwnerMaterialization(scope, runtime, declaration, bind
 	let binding;
 	try {
 		if (bindingInput.attemptId !== state.attemptId) throw new ValidationError("scope owner execution binding does not use the kernel-minted attempt id");
-		if (canonicalAgentProfileDigest(declaration.effectiveProfile) !== state.authoredProfileDigest) throw new ValidationError("scope owner stable effective profile conflicts with its admitted authored profile");
 		receipt = knownMaterializationReceipt({
 			authoredProfileDigest: state.authoredProfileDigest,
 			runtime,
@@ -15145,7 +16193,7 @@ function errMessage(err) {
 * journal so the executor can run its `act` inside a nested scope. `act` fails loud if
 * called directly — a driver child runs THROUGH its nested-scope executor, never as a root.
 */
-function driverChild(profile, driver, journal, execution) {
+function driverChild(profile, driver, journal, execution, acceptedSubmission) {
 	const name = profile.name ?? driver.name;
 	const spec = executableAgentSpecSnapshot({
 		profile,
@@ -15153,7 +16201,8 @@ function driverChild(profile, driver, journal, execution) {
 		...execution ? { execution } : {},
 		driverRuntime,
 		driver,
-		journal
+		journal,
+		...acceptedSubmission ? { acceptedSubmission } : {}
 	}, "driverChild");
 	const deliver = driver.deliver?.bind(driver);
 	return {
@@ -15232,7 +16281,7 @@ const driverExecutorFactory = (rawSpec, ctx) => {
 					reported: childWork,
 					reservation: addSpend(childWork, meteredSpend ?? zeroSpend())
 				};
-				const verdict = deriveDeliveryVerdict(settled, out);
+				const verdict = deriveDeliveryVerdict(settled, out, spec.acceptedSubmission?.() === true);
 				artifact = {
 					outRef: `${driverRuntime}:${nestedRoot}`,
 					out,
@@ -15351,13 +16400,18 @@ async function safeRollup(journal, nestedRoot) {
 		return;
 	}
 }
-/** Derive the driver child's delivery verdict from its DIRECT children's settlements and the
-*  manager's actual finalized output: `valid` iff a direct child delivered AND the finalizer
-*  returned a defined output;
+/** Derive the driver child's delivery verdict from an accepted direct submission, or from its
+*  DIRECT children's settlements and the manager's actual finalized output: `valid` iff the
+*  manager's own assignment check accepted a submission, or a direct child delivered AND the
+*  finalizer returned a defined output;
 *  `score` = the best delivered score. Returns `undefined` when no child settled at all (the
 *  driver itself produced nothing to bubble a verdict from). Fail-closed: a child whose verdict
 *  carried no `valid` counts as not-delivered. */
-function deriveDeliveryVerdict(settled, finalizedOutput) {
+function deriveDeliveryVerdict(settled, finalizedOutput, acceptedSubmission) {
+	if (acceptedSubmission) return {
+		valid: true,
+		score: 1
+	};
 	let sawChild = false;
 	let anyValid = false;
 	let bestValidScore;
@@ -16087,10 +17141,10 @@ async function drainLiveChildren(scope, controller, settleGraceMs = 0) {
 	const view = scope.view;
 	if (!(view.inFlight > 0 || view.waiting > 0)) return unconfirmedTeardowns(scope);
 	let graceTimer;
-	if (settleGraceMs > 0 && !controller.signal.aborted) {
+	if (settleGraceMs !== null && settleGraceMs > 0 && !controller.signal.aborted) {
 		graceTimer = setTimeout(() => controller.abort("root driver failed; child settle grace expired"), settleGraceMs);
 		graceTimer.unref?.();
-	} else if (!controller.signal.aborted) controller.abort("root driver failed; no child settle grace configured");
+	} else if (settleGraceMs !== null && !controller.signal.aborted) controller.abort("root driver failed; no child settle grace configured");
 	try {
 		await drainCursor(scope);
 	} finally {
@@ -16118,9 +17172,11 @@ function describeUnconfirmed(scope) {
 	const named = scope.workerCapacity.unconfirmed.map((node) => `${node.id} (${node.label}, ${node.runtime}, ${node.status})`).join(", ");
 	return `${scope.workerCapacity.live} executor resource(s) not confirmed destroyed${named.length > 0 ? `: ${named}` : ""}`;
 }
-/** The settle window a failed driver's children actually get: the caller's grace, never past the
-*  run's own deadline. `0` (the default) keeps the historical immediate cascade. */
+/** The settle window a driver's children actually get: the caller's grace, never past an explicit
+*  run deadline. `null` means no timer. `0` (the default) cascades immediately. */
 function boundedSettleGrace(graceMs, deadlineAtMs, now) {
+	if (graceMs === null && deadlineAtMs <= 0) return null;
+	if (graceMs === null) return Math.max(0, deadlineAtMs - now());
 	if (graceMs === void 0 || graceMs <= 0) return 0;
 	if (deadlineAtMs <= 0) return graceMs;
 	return Math.max(0, Math.min(graceMs, deadlineAtMs - now()));
@@ -16347,6 +17403,6 @@ function resolveRedactor(redact) {
 	return (value) => defaultRedactor(redact(value));
 }
 //#endregion
-export { createBudgetPool as $, addHarnessUsage as $t, interactiveAdmissionSeamKey as A, DEFAULT_LOCAL_HARNESS as An, claimsAuthority as At, reconnectRetainedRun as B, fullProfileMaterialization as Bn, createSandboxForSpec as Bt, settledToIteration as C, sanitizeKnowledgeReadinessReport as Cn, DEFAULT_STALL_AFTER_MS as Ct, timerAt as D, captureWorktreeDiff as Dn, AUTHORITY_MARKERS as Dt, pollFor as E, runWorktreeHarness as En, createInbox as Et, workerInteractiveBindingFile as F, CodexExecutionDiagnosticError as Fn, isLiveNodeStatus as Ft, destroyInteractiveEnvironment as G, promptResourceProfileMaterialization as Gn, probeSandboxCapabilities as Gt, startRetainedRun as H, promptControlProfileMaterialization as Hn, isTerminalDecision as Ht, workerInteractiveBindingsDir as I, AGENT_PROFILE_MATERIALIZATION_AXES as In, isTerminalNodeStatus as It, queueOf as J, sandboxActProfileMaterialization as Jn, readPromptOptions as Jt, effectiveConcurrency as K, renderProfileMaterializationIssues as Kn, acquireSandbox as Kt, reconnectRetainedInteractiveRun as L, assertProfileMaterialization as Ln, createInPlaceCliExecutor as Lt, workerInteractiveAdmissionFile as M, harnessSupportsReasoningEffort as Mn, isPeerMailEnvelope as Mt, attachWorker as N, localHarnessExecutable as Nn, peerMailTools as Nt, validateWaitSpec as O, createWorktree as On, DEFAULT_PEER_MAIL_LIMITS as Ot, readWorkerInteractiveBinding as P, parseCodexTokenUsage as Pn, peerMailVerbNames as Pt, assertValidBudget as Q, observedModelMatchesDeclared as Qt, recoverRetainedInteractiveRun as R, controlProfileMaterialization as Rn, taskToPrompt as Rt, scopeOwnerExecutorNodeContext as S, sanitizeAgentRuntimeEvent as Sn, sandboxSessionTraceSource as St, isWaitOutcome as T, runSettledCommand as Tn, readWorkerProgress as Tt, startRetainedRunInEnvironment as U, promptModelProfileMaterialization as Un, runAgentRounds as Ut, recoverRetainedRun as V, profileMaterializationAxes$1 as Vn, defaultSelectWinner as Vt, retainedCreateMaterial as W, promptOnlyProfileMaterialization as Wn, createSandboxLineage as Wt, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as X, validateProfileMaterialization as Xn, runBrainLoop as Xt, rollingDispatch as Y, unsupportedProfileDimensions as Yn, routerBrain as Yt, teardownExecutor as Z, worktreeCliProfileMaterialization as Zn, canonicalObservedModelParts as Zt, createScope as _, padSpanId as _n, workerTraceSeamKey as _t, createSupervisor as a, readTraceContextFromEnv as an, bridgeStopSignalKey as at, meterRuntimeOwnedProviderAttempt as b, createRuntimeEventCollector as bn, createPushTraceSource as bt, uncertainSpawnBudgets as c, buildLoopOtelSpans as cn, cliWorktreeExecutor as ct, pickBestDelivered as d, createOpenInferenceFileExporter as dn, snapshotExecutorConfig as dt, createCodexRolloutStoreReader as en, spendFromUsageEvents as et, runFinalizer as f, createOtelExporter as fn, createWorktreeCliExecutor as ft, beginScopeOwnerAttempt as g, loopEventToOtelSpan as gn, workerTraceHeaders as gt, withDriverExecutor as h, generateSpanId as hn, workerTraceEnv as ht, createRootHandle as i, mergeTraceEnv as in, bridgeRuntimeAttachmentsKey as it, readWorkerInteractiveAdmissions as j, LOCAL_HARNESSES as jn, createPeerMailbox as jt, waitUntil as k, removeWorktree as kn, PEER_MAIL_WIRE_KEY as kt, bestDelivered as l, buildLoopSpanNodes as ln, createExecutor as lt, driverChild as m, flatOtelSpan as mn, readWorkerTraceContext as mt, defaultRedactorIdentityMaterial as n, readCodexRolloutSession as nn, bridgeAdmissionRead as nt, maxSeqOf as o, traceContextToEnv as on, captureReusableExecutorConfig as ot, runTree as p, exportEvalRuns as pn, WORKER_TRACE_PROPAGATION as pt, freeSlots as q, renderUnsupported as qn, assertBoxlessPromptOptions as qt, resolveRedactor as r, createPropagatingTraceEmitter as rn, bridgeModelRouteRefusal as rt, sumMeasuredSpendFromEvents as s, INTELLIGENCE_WIRE_VERSION as sn, cliInPlaceExecutor as st, defaultRedactor as t, harnessUsageIsEmpty as tn, bindReusableExecutorExecutionId as tt, collectDelivered as u, buildRuntimeEventOtelSpans as un, createExecutorRegistry as ut, deriveNodeExecutionIdentity as v, padTraceId as vn, DEFAULT_SANDBOX_STEERING_MAX_TURNS as vt, createWaitProbes as w, sanitizeRuntimeStreamEvent as wn, createActivityLog as wt, recordScopeOwnerMaterialization as x, createRuntimeStreamEventCollector as xn, decodeToolPart as xt, meterRuntimeOwnedAccounting as y, toOtelAttributes as yn, createSteerableSandboxSession as yt, startRetainedInteractiveRun as z, defineProfileMaterializationContract as zn, TERMINAL_DECISIONS as zt };
+export { createBudgetPool as $, assertProfileMaterialization as $n, workerTraceAnalysisStore as $t, interactiveAdmissionSeamKey as A, flatOtelSpan as An, claimsAuthority as At, reconnectRetainedRun as B, sanitizeRuntimeStreamEvent as Bn, FileSpawnJournal as Bt, settledToIteration as C, INTELLIGENCE_WIRE_VERSION as Cn, DEFAULT_STALL_AFTER_MS as Ct, timerAt as D, createOpenInferenceFileExporter as Dn, AUTHORITY_MARKERS as Dt, pollFor as E, buildRuntimeEventOtelSpans as En, createInbox as Et, workerInteractiveBindingFile as F, toOtelAttributes as Fn, isLiveNodeStatus as Ft, destroyInteractiveEnvironment as G, removeWorktree as Gn, loadSpawnForest as Gt, startRetainedRun as H, runWorktreeHarness as Hn, InMemorySpawnJournal as Ht, workerInteractiveBindingsDir as I, createRuntimeEventCollector as In, isTerminalNodeStatus as It, queueOf as J, harnessSupportsReasoningEffort as Jn, replaySpawnTree as Jt, effectiveConcurrency as K, DEFAULT_LOCAL_HARNESS as Kn, materializeTreeView as Kt, reconnectRetainedInteractiveRun as L, createRuntimeStreamEventCollector as Ln, createInPlaceCliExecutor as Lt, workerInteractiveAdmissionFile as M, loopEventToOtelSpan as Mn, isPeerMailEnvelope as Mt, attachWorker as N, padSpanId as Nn, peerMailTools as Nt, validateWaitSpec as O, createOtelExporter as On, DEFAULT_PEER_MAIL_LIMITS as Ot, readWorkerInteractiveBinding as P, padTraceId as Pn, peerMailVerbNames as Pt, assertValidBudget as Q, AGENT_PROFILE_MATERIALIZATION_AXES as Qn, parseWorkerToolTraceArtifact as Qt, recoverRetainedInteractiveRun as R, sanitizeAgentRuntimeEvent as Rn, taskToPrompt as Rt, scopeOwnerExecutorNodeContext as S, traceContextToEnv as Sn, sandboxSessionTraceSource as St, isWaitOutcome as T, buildLoopSpanNodes as Tn, readWorkerProgress as Tt, startRetainedRunInEnvironment as U, captureWorktreeDiff as Un, closesCursorSlot as Ut, recoverRetainedRun as V, runSettledCommand as Vn, InMemoryResultBlobStore as Vt, retainedCreateMaterial as W, createWorktree as Wn, insideCursorNamespace as Wt, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as X, parseCodexTokenUsage as Xn, captureWorkerTraceEvidence as Xt, rollingDispatch as Y, localHarnessExecutable as Yn, WORKER_TOOL_TRACE_SCHEMA_VERSION as Yt, teardownExecutor as Z, CodexExecutionDiagnosticError as Zn, isTraceAnalysisStore as Zt, createScope as _, harnessUsageIsEmpty as _n, workerTraceSeamKey as _t, createSupervisor as a, runAgentRounds as an, promptModelProfileMaterialization as ar, bridgeStopSignalKey as at, meterRuntimeOwnedProviderAttempt as b, mergeTraceEnv as bn, createPushTraceSource as bt, uncertainSpawnBudgets as c, acquireSandbox as cn, renderProfileMaterializationIssues as cr, cliWorktreeExecutor as ct, pickBestDelivered as d, routerBrain as dn, unsupportedProfileDimensions as dr, snapshotExecutorConfig as dt, contentAddress as en, controlProfileMaterialization as er, spendFromUsageEvents as et, runFinalizer as f, runBrainLoop as fn, validateProfileMaterialization as fr, createWorktreeCliExecutor as ft, beginScopeOwnerAttempt as g, createCodexRolloutStoreReader as gn, workerTraceHeaders as gt, withDriverExecutor as h, addHarnessUsage as hn, workerTraceEnv as ht, createRootHandle as i, isTerminalDecision as in, promptControlProfileMaterialization as ir, bridgeRuntimeAttachmentsKey as it, readWorkerInteractiveAdmissions as j, generateSpanId as jn, createPeerMailbox as jt, waitUntil as k, exportEvalRuns as kn, PEER_MAIL_WIRE_KEY as kt, bestDelivered as l, assertBoxlessPromptOptions as ln, renderUnsupported as lr, createExecutor as lt, driverChild as m, observedModelMatchesDeclared as mn, readWorkerTraceContext as mt, defaultRedactorIdentityMaterial as n, createSandboxForSpec as nn, fullProfileMaterialization as nr, bridgeAdmissionRefusal as nt, maxSeqOf as o, createSandboxLineage as on, promptOnlyProfileMaterialization as or, captureReusableExecutorConfig as ot, runTree as p, canonicalObservedModelParts as pn, worktreeCliProfileMaterialization as pr, WORKER_TRACE_PROPAGATION as pt, freeSlots as q, LOCAL_HARNESSES as qn, pendingWaits as qt, resolveRedactor as r, defaultSelectWinner as rn, profileMaterializationAxes$1 as rr, bridgeModelRouteRefusal as rt, sumMeasuredSpendFromEvents as s, probeSandboxCapabilities as sn, promptResourceProfileMaterialization as sr, cliInPlaceExecutor as st, defaultRedactor as t, TERMINAL_DECISIONS as tn, defineProfileMaterializationContract as tr, bindReusableExecutorExecutionId as tt, collectDelivered as u, readPromptOptions as un, sandboxActProfileMaterialization as ur, createExecutorRegistry as ut, deriveNodeExecutionIdentity as v, readCodexRolloutSession as vn, DEFAULT_SANDBOX_STEERING_MAX_TURNS as vt, createWaitProbes as w, buildLoopOtelSpans as wn, createActivityLog as wt, recordScopeOwnerMaterialization as x, readTraceContextFromEnv as xn, decodeToolPart as xt, meterRuntimeOwnedAccounting as y, createPropagatingTraceEmitter as yn, createSteerableSandboxSession as yt, startRetainedInteractiveRun as z, sanitizeKnowledgeReadinessReport as zn, FileResultBlobStore as zt };
 
-//# sourceMappingURL=redact-Ct7s2j86.js.map
+//# sourceMappingURL=redact-BOU77QfQ.js.map