@tangle-network/agent-runtime 0.143.0 → 0.153.2

package/dist/durable.d.ts

@@ -1,6 +1,6 @@
-import { _o as supervise, jo as SupervisorProfile, po as SuperviseOptions } from "./index-C2caGomG.js";
+import { ao as SuperviseOptions, lo as supervise, wo as SupervisorProfile } from "./index-DLn9WI-f.js";
 import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
-import { x as NodeId } from "./types-Df9vulGc.js";
+import { A as ProviderModelExecutionEvidence, O as ProfileMaterializationReceipt, T as NodeId, Y as SpendGap, ct as WorkerTraceEvidence, o as ExecutionBindingReceipt, q as Spend } from "./types-BPQhQRrC.js";
 //#region src/durable/chat-engine.d.ts
 /**
  * `handleChatTurn` is a framework-neutral chat-turn HTTP orchestrator.
@@ -198,6 +198,66 @@ declare function createFileObserverHooks(path: string, pursuitId: string): {
 //#endregion
 //#region src/durable/observer-projection.d.ts
 type PursuitRunStatus = 'running' | 'done' | 'failed';
+/**
+ * Where a node's dollar figure came from. `reported` = a provider billed all of it; `estimated` =
+ * a model catalog priced all of it; `partial` = a provider billed part and a catalog priced the
+ * rest; `unknown` = nothing priced it, so `usd` is a floor and never the cost.
+ */
+type PursuitCostProvenance = 'reported' | 'estimated' | 'partial' | 'unknown';
+/**
+ * One node's token usage by class. Cache and reasoning classes are absent when the provider did
+ * not report them — absence is not zero. `tokensKnown` is `false` when work happened whose token
+ * count no provider reported, which makes `input`/`output` a floor.
+ */
+interface PursuitNodeUsage {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead?: number;
+  readonly cacheWrite?: number;
+  readonly reasoning?: number;
+  readonly tokensKnown: boolean;
+}
+/** One node's dollar cost with the provenance that decides whether it may be compared or summed. */
+interface PursuitNodeCost {
+  readonly usd: number;
+  readonly usdKnown: boolean;
+  /** The part of `usd` a model catalog priced because no provider receipt covered it. */
+  readonly usdEstimated?: number;
+  readonly provenance: PursuitCostProvenance;
+}
+/**
+ * One node's clock. `wallMs` is `settledAt - startedAt` and is deliberately distinct from the
+ * executor-reported `spent.ms` sums, which under-report and overlap across parallel children.
+ * `firstTokenAt` stays absent unless a provider reports that instant; it is never inferred from
+ * `firstOutputAt`, which is when the node first reported usage for a turn.
+ */
+interface PursuitNodeTiming {
+  readonly startedAt: number;
+  readonly firstOutputAt?: number;
+  readonly firstTokenAt?: number;
+  readonly settledAt?: number;
+  readonly wallMs?: number;
+}
+/** Where and how a node's execution was placed, read off its execution-binding receipt. */
+type PursuitNodePlacement = Readonly<Record<string, string | number | boolean | null>>;
+/**
+ * One run's spend counted once, and each node's own share of it. `inclusive` and the entries of
+ * `exclusiveByNode` are the two views a client needs to show a tree without double counting.
+ */
+interface PursuitRunTotals {
+  /**
+   * The whole run counted once. A node's settled `spent` already contains the child work its own
+   * nested tree reported, so summing only the run's top-level nodes plus every node's own
+   * inference counts each model call exactly once.
+   */
+  readonly inclusive: Spend;
+  /**
+   * Each node's own share: its reported spend and own inference minus what its direct children
+   * reported. Keyed by node id, plus the run root when the root itself metered inference. The
+   * entries sum to `inclusive` by construction.
+   */
+  readonly exclusiveByNode: Readonly<Record<string, Spend>>;
+}
 interface PursuitRunProjection {
   readonly runId: string;
   readonly status: PursuitRunStatus;
@@ -211,6 +271,9 @@ interface PursuitRunProjection {
   readonly decisionCount: number;
   readonly targets: Readonly<Record<string, number>>;
   readonly decisions: Readonly<Record<string, number>>;
+  readonly totals: PursuitRunTotals;
+  /** The nodes whose accounting is incomplete. Present exactly when non-empty. */
+  readonly spendGaps?: ReadonlyArray<SpendGap>;
 }
 type PursuitNodeStatus = 'running' | 'done' | 'down';
 interface PursuitNodeProjection {
@@ -219,6 +282,7 @@ interface PursuitNodeProjection {
   /** Node ids are scoped to this concrete Runtime tree; `(runId,id)` is identity. */
   readonly runId: string;
   readonly label?: string;
+  /** The runner that executed this node — the executor's own name, not a harness guess. */
   readonly runtime?: string;
   readonly depth?: number;
   readonly assignmentId?: string;
@@ -226,18 +290,48 @@ interface PursuitNodeProjection {
   readonly budget?: unknown;
   readonly status: PursuitNodeStatus;
   readonly settledAt?: number;
-  readonly spent?: unknown;
+  /** The child work this node reported at settlement. Absent until a terminal record lands. */
+  readonly spent?: Spend;
+  /** This node's OWN inference, re-homed from its nested tree. Absent when it drove no turns. */
+  readonly ownInference?: Spend;
+  /** Absent until a spend record lands; the run's `spendGaps` then names the node. */
+  readonly usage?: PursuitNodeUsage;
+  /** Absent until a spend record lands; the run's `spendGaps` then names the node. */
+  readonly cost?: PursuitNodeCost;
+  readonly timing?: PursuitNodeTiming;
+  /** The kernel-minted attempt this node's execution binding is keyed on. */
+  readonly attemptId?: string;
+  /** The runner-native execution the node bound to: a request, session, run, process, or tree. */
+  readonly execution?: {
+    readonly kind: string;
+    readonly id: string;
+  };
+  /** The model the materialization receipt names, when the runner reported one. */
+  readonly model?: string;
+  /** The concrete backend the profile materialized onto. */
+  readonly backend?: string;
+  readonly placement?: PursuitNodePlacement;
+  /** Model-call identifiers this node's own turns reported, in order, deduplicated. */
+  readonly modelCalls?: ReadonlyArray<string>;
+  readonly materialization?: ProfileMaterializationReceipt;
+  readonly executionBindings?: ReadonlyArray<ExecutionBindingReceipt>;
+  /** What the provider itself reported serving, and why it is unknown when it is. */
+  readonly providerModel?: ProviderModelExecutionEvidence;
+  /** Content-addressed pointer to this node's persisted tool trace, or why there is none. */
+  readonly trace?: WorkerTraceEvidence;
   readonly outRef?: string;
   readonly score?: number;
   readonly valid?: boolean;
   readonly reason?: string;
   readonly infra?: boolean;
+  readonly restartCount?: number;
   readonly wait?: unknown;
   readonly firstSequence: number;
   readonly lastSequence: number;
   readonly firstObservedAt: number;
   readonly lastObservedAt: number;
   readonly eventCount: number;
+  readonly turnCount: number;
 }
 interface PursuitProjection {
   readonly pursuitId: string;
@@ -264,6 +358,10 @@ interface PursuitProjection {
  * state comes only from `agent.child`; concrete run state comes only from the root
  * `agent.run` lifecycle emitted by `supervisePursuit`. Node identity is scoped to the
  * concrete Runtime run so independent trees may both contain `root:s0` without aliasing.
+ *
+ * Usage, cost and timing are reported at the class the runtime measured them at. A missing
+ * class stays ABSENT and the run names the node in `spendGaps`; nothing here converts an
+ * unmeasured channel into a zero, because a fabricated zero is indistinguishable from free work.
  */
 declare function projectPursuit(records: readonly ObserverRecord[]): PursuitProjection;
 //#endregion
@@ -335,5 +433,5 @@ interface DurableSupervisionDiscovery {
  */
 declare function discoverDurableSupervisionRun(runDir: string): Promise<DurableSupervisionDiscovery>;
 //#endregion
-export { type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type DurableCoordinationStreamIdentity, type DurableSupervisionDiscovery, FileObserverJournal, type ObserverJournal, type ObserverRecord, type ObserverRecordKind, type PursuitNodeProjection, type PursuitNodeStatus, type PursuitProjection, type PursuitRunProjection, type PursuitRunStatus, type RunChatTurnInput, SupervisePursuitError, type SupervisePursuitOptions, type SupervisedPursuitResult, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, supervisePursuit, verifyObserverRecords };
+export { type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type DurableCoordinationStreamIdentity, type DurableSupervisionDiscovery, FileObserverJournal, type ObserverJournal, type ObserverRecord, type ObserverRecordKind, type PursuitCostProvenance, type PursuitNodeCost, type PursuitNodePlacement, type PursuitNodeProjection, type PursuitNodeStatus, type PursuitNodeTiming, type PursuitNodeUsage, type PursuitProjection, type PursuitRunProjection, type PursuitRunStatus, type PursuitRunTotals, type RunChatTurnInput, SupervisePursuitError, type SupervisePursuitOptions, type SupervisedPursuitResult, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, supervisePursuit, verifyObserverRecords };
 //# sourceMappingURL=durable.d.ts.map

package/dist/durable.js

@@ -1,6 +1,7 @@
-import { d as prepareJsonlAppend, f as writeAllBytes, u as parseCommittedJsonLines } from "./spawn-journal-D2HKUImC.js";
+import { i as cloneSpend, t as addSpend, y as zeroSpend } from "./util-D6ZEuBMi.js";
+import { i as writeAllBytes, n as parseCommittedJsonLines, r as prepareJsonlAppend, t as isNoEntError } from "./jsonl-file-CDfsCI5s.js";
 import { a as withPursuitContext, t as composeRuntimeHooks } from "./runtime-hooks-tXpAarhW.js";
-import { n as supervise } from "./supervise-hCgG6ROJ.js";
+import { n as supervise } from "./supervise-k_8VOASb.js";
 import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import { readFile } from "node:fs/promises";
@@ -301,6 +302,10 @@ function toError(error) {
 * state comes only from `agent.child`; concrete run state comes only from the root
 * `agent.run` lifecycle emitted by `supervisePursuit`. Node identity is scoped to the
 * concrete Runtime run so independent trees may both contain `root:s0` without aliasing.
+*
+* Usage, cost and timing are reported at the class the runtime measured them at. A missing
+* class stays ABSENT and the run names the node in `spendGaps`; nothing here converts an
+* unmeasured channel into a zero, because a fabricated zero is indistinguishable from free work.
 */
 function projectPursuit(records) {
 	if (records.length === 0) throw new TypeError("projectPursuit: at least one observer record is required");
@@ -323,12 +328,19 @@ function projectPursuit(records) {
 			projectRunActivity(run, record);
 			projectSpawnNode(nodes, record);
 			projectNodeActivity(nodes, record);
+			projectTurn(runs, nodes, record);
 		} else if (record.decision) {
 			decisionCount += 1;
 			run.decisionCount += 1;
 			increment(run.decisions, record.decision.kind);
 		}
 	}
+	const byRun = /* @__PURE__ */ new Map();
+	for (const node of nodes.values()) {
+		const list = byRun.get(node.runId);
+		if (list) list.push(node);
+		else byRun.set(node.runId, [node]);
+	}
 	const first = verified[0];
 	const last = verified.at(-1);
 	return Object.freeze({
@@ -337,7 +349,7 @@ function projectPursuit(records) {
 		chainTip: last.digest,
 		firstObservedAt: first.observedAt,
 		lastObservedAt: last.observedAt,
-		runs: Object.freeze([...runs.values()].sort((a, b) => a.firstSequence - b.firstSequence || a.runId.localeCompare(b.runId)).map(freezeRun)),
+		runs: Object.freeze([...runs.values()].sort((a, b) => a.firstSequence - b.firstSequence || a.runId.localeCompare(b.runId)).map((run) => freezeRun(run, byRun.get(run.runId) ?? []))),
 		nodes: Object.freeze([...nodes.values()].sort((a, b) => a.firstSequence - b.firstSequence || a.runId.localeCompare(b.runId) || a.id.localeCompare(b.id)).map(freezeNode)),
 		eventCount,
 		decisionCount
@@ -398,6 +410,8 @@ function projectSpawnNode(nodes, record) {
 	const runtime = stringField(payload, "runtime");
 	const depth = numberField(payload, "depth");
 	const assignmentId = stringField(payload, "assignmentId");
+	const attemptId = stringField(payload, "attemptId");
+	const startedAt = numberField(payload, "startedAt");
 	nodes.set(key, {
 		id: childId,
 		...event.parentId ? { parentId: event.parentId } : {},
@@ -406,14 +420,18 @@ function projectSpawnNode(nodes, record) {
 		...runtime ? { runtime } : {},
 		...depth !== void 0 ? { depth } : {},
 		...assignmentId ? { assignmentId } : {},
+		...attemptId ? { attemptId } : {},
+		startedAt: startedAt ?? record.observedAt,
 		...payload && Object.hasOwn(payload, "identity") ? { identity: payload.identity } : {},
 		...payload && Object.hasOwn(payload, "budget") ? { budget: payload.budget } : {},
 		status: "running",
+		modelCalls: [],
 		firstSequence: record.sequence,
 		lastSequence: record.sequence,
 		firstObservedAt: record.observedAt,
 		lastObservedAt: record.observedAt,
-		eventCount: 1
+		eventCount: 1,
+		turnCount: 0
 	});
 }
 function projectNodeActivity(nodes, record) {
@@ -432,8 +450,14 @@ function projectNodeActivity(nodes, record) {
 	const status = stringField(payload, "status");
 	if (status !== "done" && status !== "down") return;
 	node.status = status;
-	node.settledAt = record.observedAt;
-	if (payload && Object.hasOwn(payload, "spent")) node.spent = payload.spent;
+	node.settledAt = numberField(payload, "settledAt") ?? record.observedAt;
+	const startedAt = numberField(payload, "startedAt");
+	if (startedAt !== void 0) node.startedAt = startedAt;
+	if (payload && Object.hasOwn(payload, "spent")) node.spent = spendField(payload, "spent");
+	const metered = spendField(payload, "metered");
+	if (metered) node.ownInference = node.ownInference ? addSpend(node.ownInference, metered) : metered;
+	const runtime = stringField(payload, "runtime");
+	if (runtime) node.runtime = runtime;
 	const outRef = stringField(payload, "outRef");
 	if (outRef) node.outRef = outRef;
 	const score = numberField(payload, "score");
@@ -444,17 +468,232 @@ function projectNodeActivity(nodes, record) {
 	if (reason) node.reason = reason;
 	const infra = booleanField(payload, "infra");
 	if (infra !== void 0) node.infra = infra;
+	const restartCount = numberField(payload, "restartCount");
+	if (restartCount !== void 0) node.restartCount = restartCount;
 	if (payload && Object.hasOwn(payload, "wait")) node.wait = payload.wait;
+	attachSettlementEvidence(node, payload);
+}
+/**
+* Read the receipts a settlement carries. Each is taken as reported: an `unknown` receipt keeps
+* its `status` and `reason` so a client can show WHY a model or backend is missing instead of
+* showing nothing, and a receipt that never landed leaves every derived field absent.
+*/
+function attachSettlementEvidence(node, payload) {
+	const providerModel = payload?.providerModel;
+	if (providerModel && typeof providerModel === "object") node.providerModel = providerModel;
+	const trace = payload?.trace;
+	if (trace && typeof trace === "object") node.trace = trace;
+	const bindings = payload?.executionBindings;
+	if (Array.isArray(bindings) && bindings.length > 0) {
+		node.executionBindings = bindings;
+		const known = bindings.find((binding) => objectRecord(binding)?.status === "known");
+		if (known) {
+			node.placement = known.descriptor;
+			node.attemptId ??= known.attemptId;
+		}
+	}
+	const receipt = payload?.materialization;
+	if (!receipt || typeof receipt !== "object") return;
+	node.materialization = receipt;
+	if (receipt.status !== "known") return;
+	node.backend = receipt.backend;
+	if (receipt.model.status === "known") node.model = receipt.model.id;
+	node.execution = {
+		kind: receipt.execution.kind,
+		id: receipt.execution.id
+	};
+}
+/**
+* Fold one metered turn onto whoever drove it. `agent.turn` names its subject in `parentId` — the
+* node making the call — not in the payload, because the caller IS the subject. A turn the run
+* root drove belongs to no spawned node and lands on the run instead, so the run's totals stay
+* complete without inventing a node for the root.
+*/
+function projectTurn(runs, nodes, record) {
+	const event = record.event;
+	if (event?.target !== "agent.turn") return;
+	const payload = objectRecord(event.payload);
+	const spend = spendField(payload, "spend");
+	const subject = event.parentId;
+	if (subject === void 0) return;
+	const node = nodes.get(nodeKey(event.runId, subject));
+	if (!node) {
+		if (!spend) return;
+		const run = runs.get(event.runId);
+		if (!run) return;
+		run.rootInference = run.rootInference ? addSpend(run.rootInference, spend) : spend;
+		return;
+	}
+	node.turnCount += 1;
+	node.lastSequence = record.sequence;
+	node.lastObservedAt = record.observedAt;
+	if (spend) {
+		node.ownInference = node.ownInference ? addSpend(node.ownInference, spend) : spend;
+		node.firstOutputAt ??= record.observedAt;
+	}
+	const reasoning = numberField(payload, "reasoningTokens");
+	if (reasoning !== void 0) node.reasoningTokens = (node.reasoningTokens ?? 0) + reasoning;
+	const firstTokenAt = numberField(payload, "firstTokenAt");
+	if (firstTokenAt !== void 0) node.firstTokenAt ??= firstTokenAt;
+	const model = stringField(payload, "model");
+	if (model) node.model ??= model;
+	const callId = stringField(payload, "callId");
+	if (callId && !node.modelCalls.includes(callId)) node.modelCalls.push(callId);
+}
+/**
+* A node's whole reported cost: the child work its settlement reported plus the inference it drove
+* itself. `undefined` when neither landed — the run's `spendGaps` then names the node, so an
+* unaccounted node is visible instead of reading as free.
+*/
+function nodeTotal(node) {
+	if (node.spent && node.ownInference) return addSpend(node.spent, node.ownInference);
+	if (node.spent) return cloneSpend(node.spent);
+	if (node.ownInference) return cloneSpend(node.ownInference);
+}
+/**
+* The run counted once, and each node's own share of it.
+*
+* A settled node's `spent` already contains the child work its nested tree reported, so summing
+* every node would count a driver's descendants twice. Inclusive therefore sums only the run's
+* TOP-LEVEL nodes — those whose parent is not another node of this run — plus the root's own
+* turns. Exclusive subtracts each node's direct children from its own total, which telescopes:
+* the exclusive entries sum back to `inclusive` exactly.
+*/
+function runTotals(run, nodes) {
+	const present = new Set(nodes.map((node) => node.id));
+	const children = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		if (node.parentId === void 0 || !present.has(node.parentId)) continue;
+		const list = children.get(node.parentId);
+		if (list) list.push(node);
+		else children.set(node.parentId, [node]);
+	}
+	const exclusiveByNode = {};
+	let inclusive = run.rootInference ? cloneSpend(run.rootInference) : zeroSpend();
+	if (run.rootInference) exclusiveByNode[run.runId] = cloneSpend(run.rootInference);
+	for (const node of nodes) {
+		const total = nodeTotal(node);
+		if (total === void 0) continue;
+		if (node.parentId === void 0 || !present.has(node.parentId)) inclusive = addSpend(inclusive, total);
+		let exclusive = total;
+		for (const child of children.get(node.id) ?? []) {
+			const childTotal = nodeTotal(child);
+			if (childTotal !== void 0) exclusive = subtractSpend(exclusive, childTotal);
+		}
+		exclusiveByNode[node.id] = exclusive;
+	}
+	return Object.freeze({
+		inclusive: Object.freeze(inclusive),
+		exclusiveByNode: Object.freeze(exclusiveByNode)
+	});
+}
+/**
+* Remove a child's reported total from its parent's. Per channel, never below zero: a parent whose
+* executor reported less than its children did is a reporting gap, and a negative exclusive share
+* would be a fabricated number rather than a measurement.
+*/
+function subtractSpend(a, b) {
+	const tokens = { ...a.tokens };
+	tokens.input = Math.max(0, tokens.input - b.tokens.input);
+	tokens.output = Math.max(0, tokens.output - b.tokens.output);
+	if (a.tokens.cacheRead !== void 0) tokens.cacheRead = Math.max(0, a.tokens.cacheRead - (b.tokens.cacheRead ?? 0));
+	if (a.tokens.cacheWrite !== void 0) tokens.cacheWrite = Math.max(0, a.tokens.cacheWrite - (b.tokens.cacheWrite ?? 0));
+	if (a.tokens.freshInput !== void 0) tokens.freshInput = Math.max(0, a.tokens.freshInput - (b.tokens.freshInput ?? 0));
+	return {
+		iterations: Math.max(0, a.iterations - b.iterations),
+		tokens,
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: Math.max(0, a.usd - b.usd),
+		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
+		...a.usdEstimated !== void 0 ? { usdEstimated: Math.max(0, a.usdEstimated - (b.usdEstimated ?? 0)) } : {},
+		ms: Math.max(0, a.ms - b.ms)
+	};
+}
+/** The nodes of one run whose accounting is incomplete, in the vocabulary the supervisor already
+*  uses: `never-settled` = no terminal record, so every channel is unaccounted; `unreported` = a
+*  record landed with a channel the provider did not report, so that channel is a floor. */
+function runSpendGaps(nodes) {
+	const gaps = [];
+	for (const node of nodes) {
+		const label = node.label;
+		if (node.status === "running") {
+			gaps.push({
+				id: node.id,
+				...label !== void 0 ? { label } : {},
+				kind: "never-settled",
+				channels: ["tokens", "usd"]
+			});
+			continue;
+		}
+		const total = nodeTotal(node);
+		const channels = [];
+		if (total === void 0 || total.tokensKnown === false) channels.push("tokens");
+		if (total === void 0 || total.usdKnown === false) channels.push("usd");
+		if (channels.length === 0) continue;
+		gaps.push({
+			id: node.id,
+			...label !== void 0 ? { label } : {},
+			kind: "unreported",
+			channels
+		});
+	}
+	return gaps;
 }
-function freezeRun(run) {
+function usageOf(total, reasoning) {
+	return {
+		input: total.tokens.input,
+		output: total.tokens.output,
+		...total.tokens.cacheRead !== void 0 ? { cacheRead: total.tokens.cacheRead } : {},
+		...total.tokens.cacheWrite !== void 0 ? { cacheWrite: total.tokens.cacheWrite } : {},
+		...reasoning !== void 0 ? { reasoning } : {},
+		tokensKnown: total.tokensKnown !== false && total.tokens.tokensKnown !== false
+	};
+}
+function costOf(total) {
+	const usdKnown = total.usdKnown !== false;
+	const estimated = total.usdEstimated;
+	const provenance = usdKnown ? estimated === void 0 || estimated === 0 ? "reported" : "partial" : estimated === void 0 ? "unknown" : estimated >= total.usd ? "estimated" : "partial";
+	return {
+		usd: total.usd,
+		usdKnown,
+		...estimated !== void 0 ? { usdEstimated: estimated } : {},
+		provenance
+	};
+}
+function timingOf(node) {
+	if (node.startedAt === void 0) return void 0;
+	return {
+		startedAt: node.startedAt,
+		...node.firstOutputAt !== void 0 ? { firstOutputAt: node.firstOutputAt } : {},
+		...node.firstTokenAt !== void 0 ? { firstTokenAt: node.firstTokenAt } : {},
+		...node.settledAt !== void 0 ? { settledAt: node.settledAt } : {},
+		...node.settledAt !== void 0 ? { wallMs: Math.max(0, node.settledAt - node.startedAt) } : {}
+	};
+}
+function freezeRun(run, nodes) {
+	const gaps = runSpendGaps(nodes);
+	const { rootInference: _rootInference, ...rest } = run;
 	return Object.freeze({
-		...run,
+		...rest,
 		targets: Object.freeze({ ...run.targets }),
-		decisions: Object.freeze({ ...run.decisions })
+		decisions: Object.freeze({ ...run.decisions }),
+		totals: runTotals(run, nodes),
+		...gaps.length > 0 ? { spendGaps: Object.freeze(gaps) } : {}
 	});
 }
 function freezeNode(node) {
-	return Object.freeze({ ...node });
+	const { modelCalls, reasoningTokens, startedAt: _startedAt, ...rest } = node;
+	const total = nodeTotal(node);
+	const timing = timingOf(node);
+	return Object.freeze({
+		...rest,
+		...modelCalls.length > 0 ? { modelCalls: Object.freeze([...modelCalls]) } : {},
+		...total !== void 0 ? {
+			usage: usageOf(total, reasoningTokens),
+			cost: costOf(total)
+		} : {},
+		...timing !== void 0 ? { timing } : {}
+	});
 }
 function increment(target, key) {
 	target[key] = (target[key] ?? 0) + 1;
@@ -462,6 +701,16 @@ function increment(target, key) {
 function objectRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
+/** Read a journaled `Spend` without trusting the wire: a record missing the conserved channels is
+*  not a zero-cost turn, it is an unparseable one, and it must not enter a total. */
+function spendField(value, key) {
+	const field = objectRecord(value?.[key]);
+	if (!field) return void 0;
+	const tokens = objectRecord(field.tokens);
+	if (typeof field.usd !== "number" || !Number.isFinite(field.usd)) return void 0;
+	if (!tokens || typeof tokens.input !== "number" || typeof tokens.output !== "number") return;
+	return cloneSpend(field);
+}
 function stringField(value, key) {
 	const field = value?.[key];
 	return typeof field === "string" && field.length > 0 ? field : void 0;
@@ -627,9 +876,6 @@ function isRecord(value) {
 function compareText(left, right) {
 	return left < right ? -1 : left > right ? 1 : 0;
 }
-function isNoEntError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
 //#endregion
 export { FileObserverJournal, SupervisePursuitError, createFileObserverHooks, deriveExecutionId, discoverDurableSupervisionRun, handleChatTurn, observerRecordDigest, projectPursuit, supervisePursuit, verifyObserverRecords };