@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/spawn-journal-CwPvKUTa.js

@@ -0,0 +1,456 @@
+import { f as zeroTokenUsage } from "./util-MVgdwuIS.js";
+import { createHash } from "node:crypto";
+//#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.
+*
+* @experimental
+*/
+/**
+* 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.
+*/
+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(",")}}`;
+}
+/**
+* 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.
+*/
+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.
+*/
+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.
+*/
+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.
+*/
+var FileSpawnJournal = class {
+	path;
+	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;
+		}
+		const lines = text.split("\n").filter((line) => line.length > 0);
+		let begun = false;
+		const events = [];
+		for (const line of lines) {
+			const record = JSON.parse(line);
+			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;
+		}
+		const lines = text.split("\n").filter((line) => line.length > 0);
+		for (const line of lines) {
+			const record = JSON.parse(line);
+			if (record.root === root && record.kind === "begin") return record.at;
+		}
+	}
+	async appendRecord(record) {
+		const fs = await import("node:fs/promises");
+		const path = await import("node:path");
+		await fs.mkdir(path.dirname(this.path), { recursive: true });
+		const fh = await fs.open(this.path, "a");
+		try {
+			await fh.write(`${JSON.stringify(record)}\n`);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+};
+/**
+* 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 (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`);
+}
+/** Node-CREATION and informational records — outside the cursor namespace whose uniqueness replay
+*  ordering rests on. The single predicate both the guard's sides read, so a new event kind is
+*  classified once. */
+function outsideCursorNamespace(ev) {
+	return ev.kind === "spawned" || ev.kind === "waiting" || ev.kind === "metered";
+}
+/**
+* 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.
+*/
+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();
+	for (const ev of ordered) if (ev.kind === "spawned" || ev.kind === "waiting") labels.set(ev.id, ev.label);
+	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 === "woken") {
+			if (ev.by === "cancelled" || ev.outRef === void 0) {
+				settled.push({
+					kind: "down",
+					handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "cancelled"),
+					reason: "wait cancelled",
+					infra: false,
+					restartCount: 0,
+					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: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "done"),
+				out: outcome,
+				outRef: ev.outRef,
+				spent: zeroSpend(),
+				seq: ev.seq
+			});
+			continue;
+		}
+		if (ev.kind === "cancelled") {
+			settled.push({
+				kind: "down",
+				handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "cancelled"),
+				reason: ev.reason,
+				infra: false,
+				restartCount: 0,
+				seq: ev.seq
+			});
+			continue;
+		}
+		if (ev.status === "down") {
+			settled.push({
+				kind: "down",
+				handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "failed"),
+				reason: ev.verdict?.notes ?? "child down",
+				infra: ev.infra === true,
+				restartCount: 0,
+				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})`);
+		settled.push({
+			kind: "done",
+			handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, "done"),
+			out,
+			outRef: ev.outRef,
+			verdict: ev.verdict,
+			spent: ev.spent,
+			seq: ev.seq
+		});
+	}
+	return settled;
+}
+function replayHandle(id, label, status) {
+	return {
+		id,
+		label,
+		status,
+		abort() {
+			throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`);
+		}
+	};
+}
+/**
+* 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) => ev.kind !== "spawned" && ev.kind !== "waiting" && ev.kind !== "metered").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,
+			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 = ev.spent;
+		node.outRef = ev.outRef;
+	} else if (ev.kind === "woken") {
+		const node = requireNode(nodes, ev.id);
+		node.status = ev.by === "cancelled" ? "cancelled" : "done";
+		node.outRef = ev.outRef;
+	} else {
+		const node = requireNode(nodes, ev.id);
+		node.status = "cancelled";
+	}
+	for (const ev of events) {
+		if (ev.kind !== "metered") continue;
+		const node = requireNode(nodes, ev.id);
+		node.spent = addJournalSpend(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);
+}
+function zeroSpend() {
+	return {
+		iterations: 0,
+		tokens: zeroTokenUsage(),
+		usd: 0,
+		ms: 0
+	};
+}
+/** Add a `metered` spend record onto a node's accumulated spend (per channel). */
+function addJournalSpend(a, b) {
+	return {
+		iterations: a.iterations + b.iterations,
+		tokens: {
+			input: a.tokens.input + b.tokens.input,
+			output: a.tokens.output + b.tokens.output
+		},
+		usd: a.usd + b.usd,
+		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
+		ms: a.ms + b.ms
+	};
+}
+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,
+		spent: node.spent,
+		outRef: node.outRef
+	};
+}
+function isNoEntError(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+//#endregion
+export { contentAddress as a, replaySpawnTree as c, InMemorySpawnJournal as i, FileSpawnJournal as n, materializeTreeView as o, InMemoryResultBlobStore as r, pendingWaits as s, FileResultBlobStore as t };
+
+//# sourceMappingURL=spawn-journal-CwPvKUTa.js.map

package/dist/spawn-journal-CwPvKUTa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-journal-CwPvKUTa.js","names":[],"sources":["../src/durable/spawn-journal.ts"],"sourcesContent":["/**\n *\n * Event-sourced spawn journal for the recursive execution atom (build steps 3 + 7).\n *\n * The supervision tree is journaled as an append-only event log: every `spawned`,\n * `settled`, and `cancelled` is recorded AFTER it is observed-committed (never\n * speculative), mirroring `ConversationJournal`'s begin/append/load shape. The log\n * holds only the THIN decision record — ids, parentage, budget, the spend a decision\n * consumed, and a content-addressed `outRef`. The payloads the driver branched on\n * (the `out` artifacts) live in a separate `ResultBlobStore`, keyed by `outRef`, so\n * the journal stays small (decisions) and replay rehydrates the exact `Settled` from\n * the blob store (evidence). This is the decision/payload split the replay argument\n * rests on (B1/B2).\n *\n * Replay determinism (B2): `seq` is the monotonic cursor order `scope.next()` yielded\n * each settlement — NOT wall-clock. `replaySpawnTree` sorts strictly by `seq` before\n * touching the blob store, so the order in which rehydration `get`s resolve can never\n * reorder the replayed `Settled[]`; the result is identical regardless of blob latency.\n *\n * @experimental\n */\n\nimport { createHash } from 'node:crypto'\nimport type {\n  NodeId,\n  NodeSnapshot,\n  NodeStatus,\n  ResultBlobStore,\n  Runtime,\n  Settled,\n  SpawnEvent,\n  SpawnJournal,\n  Spend,\n  TreeView,\n} from '../runtime/supervise/types'\nimport type { PendingWait } from '../runtime/supervise/wait'\nimport { zeroTokenUsage } from '../runtime/util'\n\n// ── Content addressing ──────────────────────────────────────────────────────\n\n/**\n * Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a\n * stable JSON encoding. Producers call this to derive the `outRef` they journal and\n * `put`; the FS/in-mem stores re-derive it on `put` to verify the supplied ref\n * matches (fail loud on a mismatch — a forged ref breaks the replay invariant).\n *\n * Stable encoding: object keys are sorted recursively so two structurally-equal\n * artifacts hash identically regardless of key insertion order.\n */\nexport function contentAddress(artifact: unknown): string {\n  const hex = createHash('sha256').update(stableStringify(artifact), 'utf-8').digest('hex')\n  return `sha256:${hex}`\n}\n\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null'\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`\n  const entries = Object.entries(value as Record<string, unknown>)\n    .filter(([, v]) => v !== undefined)\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`\n}\n\n// ── Result blob store ─────────────────────────────────────────────────────────\n\n/**\n * In-memory `ResultBlobStore`. Content-addressed: `put` verifies the supplied\n * `outRef` matches the artifact's hash so a stale/forged ref fails loud rather than\n * silently rehydrating the wrong payload. Idempotent on an identical re-put.\n */\nexport class InMemoryResultBlobStore implements ResultBlobStore {\n  private readonly blobs = new Map<string, unknown>()\n\n  async put(outRef: string, artifact: unknown): Promise<void> {\n    assertContentAddress(outRef, artifact)\n    this.blobs.set(outRef, artifact)\n  }\n\n  async get(outRef: string): Promise<unknown | undefined> {\n    return this.blobs.has(outRef) ? this.blobs.get(outRef) : undefined\n  }\n}\n\n/**\n * FS `ResultBlobStore`. One JSON file per artifact under `dir`, named by a\n * filesystem-safe encoding of the `outRef` (`sha256:<hex>` → `sha256-<hex>.json`).\n * `put` fsyncs so a crash between writes never loses an acknowledged blob.\n */\nexport class FileResultBlobStore implements ResultBlobStore {\n  constructor(private readonly dir: string) {}\n\n  async put(outRef: string, artifact: unknown): Promise<void> {\n    assertContentAddress(outRef, artifact)\n    const fs = await import('node:fs/promises')\n    await fs.mkdir(this.dir, { recursive: true })\n    const fh = await fs.open(this.blobPath(outRef), 'w')\n    try {\n      await fh.write(JSON.stringify(artifact))\n      await fh.sync()\n    } finally {\n      await fh.close()\n    }\n  }\n\n  async get(outRef: string): Promise<unknown | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.blobPath(outRef), 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    return JSON.parse(text)\n  }\n\n  private blobPath(outRef: string): string {\n    return `${this.dir}/${outRef.replace(/:/g, '-')}.json`\n  }\n}\n\nfunction assertContentAddress(outRef: string, artifact: unknown): void {\n  const expected = contentAddress(artifact)\n  if (outRef !== expected) {\n    throw new Error(\n      `blob outRef '${outRef}' does not match the artifact content hash '${expected}'; ` +\n        'a content-addressed store refuses a mismatched ref (breaks the replay invariant)',\n    )\n  }\n}\n\n// ── Spawn journal ──────────────────────────────────────────────────────────────\n\n/**\n * In-memory `SpawnJournal`. Appends are observed-committed only; the impl enforces\n * the corruption guards a durable replay rests on:\n *  - an event before `beginTree` is a corrupted tree (fail loud),\n *  - a duplicate `seq` within a tree is a corrupted cursor (fail loud) — two\n *    settlements cannot share the cursor position replay orders by.\n */\nexport class InMemorySpawnJournal implements SpawnJournal {\n  private readonly trees = new Map<NodeId, { begunAt: string; events: SpawnEvent[] }>()\n\n  async loadTree(root: NodeId): Promise<SpawnEvent[] | undefined> {\n    const tree = this.trees.get(root)\n    if (!tree) return undefined\n    return tree.events.map((ev) => ({ ...ev }))\n  }\n\n  async beginTree(root: NodeId, at: string): Promise<void> {\n    const existing = this.trees.get(root)\n    if (existing) {\n      if (existing.begunAt !== at) {\n        throw new Error(\n          `spawn tree '${root}' already begun at ${existing.begunAt}; refusing to overwrite with ${at}`,\n        )\n      }\n      return\n    }\n    this.trees.set(root, { begunAt: at, events: [] })\n  }\n\n  async appendEvent(root: NodeId, ev: SpawnEvent): Promise<void> {\n    const tree = this.trees.get(root)\n    if (!tree) {\n      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`)\n    }\n    assertSeqUnique(root, tree.events, ev)\n    tree.events.push({ ...ev })\n  }\n}\n\n/**\n * JSONL on disk. One line per record: the first record is `begin`, subsequent records\n * are `event` envelopes wrapping a `SpawnEvent`. `loadTree` replays the whole file,\n * filtering by `root`, and applies the same begin-precedes-events + unique-seq\n * corruption guards as the in-memory impl. Each append fsyncs so a crash between\n * writes never loses an acknowledged event.\n */\nexport class FileSpawnJournal implements SpawnJournal {\n  constructor(private readonly path: string) {}\n\n  async loadTree(root: NodeId): Promise<SpawnEvent[] | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.path, 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    const lines = text.split('\\n').filter((line) => line.length > 0)\n    let begun = false\n    const events: SpawnEvent[] = []\n    for (const line of lines) {\n      const record = JSON.parse(line) as SpawnJournalRecord\n      if (record.root !== root) continue\n      if (record.kind === 'begin') {\n        begun = true\n      } else {\n        if (!begun) {\n          throw new Error(\n            `spawn journal corrupted: event for tree '${root}' precedes its begin record`,\n          )\n        }\n        assertSeqUnique(root, events, record.event)\n        events.push(record.event)\n      }\n    }\n    return begun ? events : undefined\n  }\n\n  async beginTree(root: NodeId, at: string): Promise<void> {\n    const existing = await this.loadTreeBegin(root)\n    if (existing) {\n      if (existing !== at) {\n        throw new Error(\n          `spawn tree '${root}' already begun in ${this.path} at ${existing}; refusing to overwrite with ${at}`,\n        )\n      }\n      return\n    }\n    await this.appendRecord({ kind: 'begin', root, at })\n  }\n\n  async appendEvent(root: NodeId, ev: SpawnEvent): Promise<void> {\n    const events = await this.loadTree(root)\n    if (events === undefined) {\n      throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`)\n    }\n    assertSeqUnique(root, events, ev)\n    await this.appendRecord({ kind: 'event', root, event: ev })\n  }\n\n  private async loadTreeBegin(root: NodeId): Promise<string | undefined> {\n    const fs = await import('node:fs/promises')\n    let text: string\n    try {\n      text = await fs.readFile(this.path, 'utf8')\n    } catch (err) {\n      if (isNoEntError(err)) return undefined\n      throw err\n    }\n    const lines = text.split('\\n').filter((line) => line.length > 0)\n    for (const line of lines) {\n      const record = JSON.parse(line) as SpawnJournalRecord\n      if (record.root === root && record.kind === 'begin') return record.at\n    }\n    return undefined\n  }\n\n  private async appendRecord(record: SpawnJournalRecord): Promise<void> {\n    const fs = await import('node:fs/promises')\n    const path = await import('node:path')\n    await fs.mkdir(path.dirname(this.path), { recursive: true })\n    const fh = await fs.open(this.path, 'a')\n    try {\n      await fh.write(`${JSON.stringify(record)}\\n`)\n      await fh.sync()\n    } finally {\n      await fh.close()\n    }\n  }\n}\n\ntype SpawnJournalRecord =\n  | { kind: 'begin'; root: NodeId; at: string }\n  | { kind: 'event'; root: NodeId; event: SpawnEvent }\n\n/**\n * Two `seq` namespaces share the journal: a `spawned` event's `seq` is the spawn ordinal\n * (the order children were created), and a `settled`/`cancelled` event's `seq` is the\n * monotonic CURSOR order `scope.next()` yielded that settlement (B2). The uniqueness\n * replay rests on is the cursor namespace — two settlements cannot share the position\n * replay orders by — so the guard checks only settled/cancelled events. A `spawned`\n * ordinal legitimately equals a later `settled` cursor seq and is not a collision.\n */\nfunction assertSeqUnique(root: NodeId, events: SpawnEvent[], ev: SpawnEvent): void {\n  // `spawned` (ordinal namespace), `waiting` (the wait-ordinal namespace — it CREATES a node, it\n  // does not settle one), and `metered` (informational spend, no settlement order) live outside\n  // the cursor-uniqueness namespace replay relies on. `woken` IS a settlement and does not.\n  if (outsideCursorNamespace(ev)) return\n  if (events.some((e) => !outsideCursorNamespace(e) && e.seq === ev.seq)) {\n    throw new Error(\n      `spawn journal corrupted: duplicate cursor seq ${ev.seq} in tree '${root}'; ` +\n        'the cursor order replay relies on is not unique',\n    )\n  }\n}\n\n/** Node-CREATION and informational records — outside the cursor namespace whose uniqueness replay\n *  ordering rests on. The single predicate both the guard's sides read, so a new event kind is\n *  classified once. */\nfunction outsideCursorNamespace(ev: SpawnEvent): boolean {\n  return ev.kind === 'spawned' || ev.kind === 'waiting' || ev.kind === 'metered'\n}\n\n// ── Replay executor (build step 7) ───────────────────────────────────────────────\n\n/**\n * Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled\n * child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly\n * as `scope.next()` originally delivered them.\n *\n * Determinism (B2): the events are sorted by `seq` BEFORE any blob `get`, so the\n * replay order is the recorded cursor order regardless of how fast each rehydration\n * resolves. `at` (wall-clock) is never a replay input. Fail loud on a tree that was\n * never begun, a settled-done event missing its `outRef`, or a blob the store can't\n * rehydrate — a silent gap would let `act` branch on the wrong evidence.\n */\nexport async function replaySpawnTree(\n  journal: SpawnJournal,\n  blobs: ResultBlobStore,\n  root: NodeId,\n): Promise<Settled<unknown>[]> {\n  const events = await journal.loadTree(root)\n  if (events === undefined) {\n    throw new Error(`replaySpawnTree: no journaled tree for root '${root}'`)\n  }\n  const ordered = [...events].sort((a, b) => a.seq - b.seq)\n  const labels = new Map<NodeId, string>()\n  for (const ev of ordered) {\n    if (ev.kind === 'spawned' || ev.kind === 'waiting') labels.set(ev.id, ev.label)\n  }\n  const settled: Settled<unknown>[] = []\n  for (const ev of ordered) {\n    if (ev.kind === 'spawned') continue\n    if (ev.kind === 'waiting') continue // arms a wait node; `woken` is its settlement\n    if (ev.kind === 'metered') continue // a spend record, not a settlement — irrelevant to replay\n    if (ev.kind === 'woken') {\n      // A wait that was cancelled carries no outcome blob — it replays as a `down`, exactly as a\n      // cancelled worker does. A fired/timed-out wait rehydrates its `WaitOutcome` and costs zero.\n      if (ev.by === 'cancelled' || ev.outRef === undefined) {\n        settled.push({\n          kind: 'down',\n          handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'cancelled'),\n          reason: 'wait cancelled',\n          infra: false,\n          restartCount: 0,\n          seq: ev.seq,\n        })\n        continue\n      }\n      const outcome = await blobs.get(ev.outRef)\n      if (outcome === undefined) {\n        throw new Error(\n          `replaySpawnTree: blob store has no wait outcome for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`,\n        )\n      }\n      settled.push({\n        kind: 'done',\n        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'done'),\n        out: outcome,\n        outRef: ev.outRef,\n        spent: zeroSpend(),\n        seq: ev.seq,\n      })\n      continue\n    }\n    if (ev.kind === 'cancelled') {\n      settled.push({\n        kind: 'down',\n        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'cancelled'),\n        reason: ev.reason,\n        infra: false,\n        restartCount: 0,\n        seq: ev.seq,\n      })\n      continue\n    }\n    if (ev.status === 'down') {\n      settled.push({\n        kind: 'down',\n        handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'failed'),\n        reason: ev.verdict?.notes ?? 'child down',\n        infra: ev.infra === true,\n        restartCount: 0,\n        seq: ev.seq,\n      })\n      continue\n    }\n    if (ev.outRef === undefined) {\n      throw new Error(\n        `replaySpawnTree: settled-done event for '${ev.id}' (seq ${ev.seq}) has no outRef; ` +\n          'cannot rehydrate the result the driver branched on',\n      )\n    }\n    const out = await blobs.get(ev.outRef)\n    if (out === undefined) {\n      throw new Error(\n        `replaySpawnTree: blob store has no artifact for outRef '${ev.outRef}' (node '${ev.id}', seq ${ev.seq})`,\n      )\n    }\n    settled.push({\n      kind: 'done',\n      handle: replayHandle(ev.id, labels.get(ev.id) ?? ev.id, 'done'),\n      out,\n      outRef: ev.outRef,\n      verdict: ev.verdict,\n      spent: ev.spent,\n      seq: ev.seq,\n    })\n  }\n  return settled\n}\n\nfunction replayHandle(id: NodeId, label: string, status: NodeStatus) {\n  return {\n    id,\n    label,\n    status,\n    abort() {\n      throw new Error(`cannot abort node '${id}': replayed handles are terminal, not live`)\n    },\n  }\n}\n\n/**\n * Materialize a recorded `TreeView` from a journaled event list for inspection. Folds\n * `spawned`/`settled`/`cancelled` into a per-node snapshot in `seq` order, then adds each\n * `metered` event's driver-inference spend onto its node in a separate additive pass so the view\n * matches the recorded cursor. It does not recover live executors or driver state after restart.\n */\nexport function materializeTreeView(events: SpawnEvent[]): TreeView {\n  const nodes = new Map<NodeId, MutableSnapshot>()\n  let root: NodeId | undefined\n  // `spawned` (ordinal namespace) and `settled`/`cancelled` (cursor namespace) carry\n  // overlapping `seq` values, so create every node before any update — process spawns in\n  // ordinal order, then settlements/cancellations in cursor order. A settle/cancel for an\n  // un-spawned node is a corrupted log (fail loud via requireNode).\n  const spawns = events\n    .filter(\n      (ev): ev is Extract<SpawnEvent, { kind: 'spawned' | 'waiting' }> =>\n        ev.kind === 'spawned' || ev.kind === 'waiting',\n    )\n    .sort((a, b) => a.seq - b.seq)\n  const settlements = events\n    .filter((ev) => ev.kind !== 'spawned' && ev.kind !== 'waiting' && ev.kind !== 'metered')\n    .sort((a, b) => a.seq - b.seq)\n  for (const ev of spawns) {\n    if (ev.kind === 'waiting') {\n      // An ARMED wait reads `waiting` until a `woken` event lands. That is the whole durability\n      // claim: a materialized tree from a journal whose process died mid-wait still shows the wait.\n      nodes.set(ev.id, {\n        id: ev.id,\n        parent: ev.parent,\n        label: ev.label,\n        status: 'waiting',\n        runtime: 'wait',\n        budget: { maxIterations: 0, maxTokens: 0 },\n        spent: zeroSpend(),\n      })\n      continue\n    }\n    if (ev.parent === undefined && root === undefined) root = ev.id\n    nodes.set(ev.id, {\n      id: ev.id,\n      parent: ev.parent,\n      label: ev.label,\n      status: 'pending',\n      runtime: ev.runtime,\n      budget: ev.budget,\n      spent: zeroSpend(),\n    })\n  }\n  for (const ev of settlements) {\n    if (ev.kind === 'settled') {\n      const node = requireNode(nodes, ev.id)\n      node.status = ev.status === 'done' ? 'done' : 'failed'\n      node.spent = ev.spent\n      node.outRef = ev.outRef\n    } else if (ev.kind === 'woken') {\n      const node = requireNode(nodes, ev.id)\n      node.status = ev.by === 'cancelled' ? 'cancelled' : 'done'\n      node.outRef = ev.outRef\n    } else {\n      const node = requireNode(nodes, ev.id)\n      node.status = 'cancelled'\n    }\n  }\n  // Driver inference: a separate pass so it accumulates ONTO the settled child-work base (no\n  // dependence on metered-vs-settled seq order) without touching node status.\n  for (const ev of events) {\n    if (ev.kind !== 'metered') continue\n    const node = requireNode(nodes, ev.id)\n    node.spent = addJournalSpend(node.spent, ev.spend)\n  }\n  const snapshots = [...nodes.values()].map(freezeSnapshot)\n  return {\n    root: root ?? snapshots[0]?.id ?? '',\n    nodes: snapshots,\n    inFlight: snapshots.filter((n) => n.status === 'running' || n.status === 'acquiring').length,\n    waiting: snapshots.filter((n) => n.status === 'waiting').length,\n  }\n}\n\n/**\n * The waits a journaled tree shows as ARMED but never woken — what a resumed run re-arms with the\n * ORIGINAL absolute deadline. Reading it from the journal (rather than from any live state) is\n * what makes \"SIGKILL a waiting tree, a new process keeps waiting to the same instant\" true.\n */\nexport function pendingWaits(events: SpawnEvent[]): PendingWait[] {\n  const woken = new Set<NodeId>()\n  for (const ev of events) if (ev.kind === 'woken') woken.add(ev.id)\n  const pending: PendingWait[] = []\n  for (const ev of events) {\n    if (ev.kind !== 'waiting' || woken.has(ev.id)) continue\n    pending.push({\n      id: ev.id,\n      label: ev.label,\n      spec: ev.spec,\n      armedAt: ev.armedAt,\n      ordinal: ev.seq,\n    })\n  }\n  return pending.sort((a, b) => a.ordinal - b.ordinal)\n}\n\ninterface MutableSnapshot {\n  id: NodeId\n  parent?: NodeId\n  label: string\n  status: NodeStatus\n  runtime: Runtime\n  budget: NodeSnapshot['budget']\n  spent: Spend\n  outRef?: string\n}\n\nfunction zeroSpend(): Spend {\n  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 }\n}\n\n/** Add a `metered` spend record onto a node's accumulated spend (per channel). */\nfunction addJournalSpend(a: Spend, b: Spend): Spend {\n  return {\n    iterations: a.iterations + b.iterations,\n    tokens: { input: a.tokens.input + b.tokens.input, output: a.tokens.output + b.tokens.output },\n    usd: a.usd + b.usd,\n    ...(a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {}),\n    ms: a.ms + b.ms,\n  }\n}\n\nfunction requireNode(nodes: Map<NodeId, MutableSnapshot>, id: NodeId): MutableSnapshot {\n  const node = nodes.get(id)\n  if (!node) {\n    throw new Error(`spawn journal corrupted: settle/cancel for node '${id}' with no prior spawn`)\n  }\n  return node\n}\n\nfunction freezeSnapshot(node: MutableSnapshot): NodeSnapshot {\n  return {\n    id: node.id,\n    parent: node.parent,\n    label: node.label,\n    status: node.status,\n    runtime: node.runtime,\n    budget: node.budget,\n    spent: node.spent,\n    outRef: node.outRef,\n  }\n}\n\nfunction isNoEntError(err: unknown): boolean {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'code' in err &&\n    (err as { code: unknown }).code === 'ENOENT'\n  )\n}\n"],"mappings":"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"}