@tangle-network/agent-runtime 0.193.1 → 0.194.0

package/dist/spawn-journal-B9eTmVAn.js

@@ -1,999 +0,0 @@
-import { m as ValidationError } from "./errors-CDZ8XsVj.js";
-import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { b as zeroSpend, i as cloneSpend, t as addSpend } from "./util-mCNUeboW.js";
-import { i as writeAllBytes, n as parseCommittedJsonLines, r as prepareJsonlAppend, t as isNoEntError } from "./jsonl-file-CDfsCI5s.js";
-import { isToolSpan, toolSpansToTraceAnalysisStore } from "@tangle-network/agent-eval";
-import { createHash } from "node:crypto";
-//#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("execution-did-not-start");
-	if (readSource === void 0) return unavailable("executor-did-not-expose-trace-source");
-	let source;
-	try {
-		source = readSource();
-	} catch {
-		return unavailable("trace-source-unavailable");
-	}
-	if (source === void 0) return unavailable("trace-source-unavailable");
-	let collected;
-	try {
-		collected = await source.collect();
-	} catch {
-		return unavailable("trace-collection-failed");
-	}
-	if (!Array.isArray(collected) || collected.some((span) => !isToolSpanValue(span))) return unavailable("invalid-tool-spans");
-	if (collected.length === 0) return unavailable("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("invalid-tool-spans");
-	}
-	try {
-		await blobs.put(traceRef, artifact);
-	} catch {
-		return unavailable("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(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
-export { captureWorkerTraceEvidence as _, aggregateProviderModelEvidence as a, workerTraceAnalysisStore as b, loadSpawnForest as c, replaySpawnTree as d, attestNestedDriverTreeOwner as f, WORKER_TOOL_TRACE_SCHEMA_VERSION as g, runtimeOwnedNestedDriverTreeRoot as h, InMemorySpawnJournal as i, materializeTreeView as l, nestedDriverTreeRoot as m, FileSpawnJournal as n, closesCursorSlot as o, driverRuntime as p, InMemoryResultBlobStore as r, insideCursorNamespace as s, FileResultBlobStore as t, pendingWaits as u, isTraceAnalysisStore as v, contentAddress as x, parseWorkerToolTraceArtifact as y };
-
-//# sourceMappingURL=spawn-journal-B9eTmVAn.js.map