@tangle-network/agent-eval 0.218.1 → 0.219.0

package/dist/{search-ledger-ClpN4I3e.js → search-ledger-CZRqtFbW.js}

@@ -62,6 +62,173 @@ function compareStrings(a, b) {
 	return a < b ? -1 : a > b ? 1 : 0;
 }
 //#endregion
+//#region src/campaign/search-state-indexes.ts
+var SearchLedgerIndexes = class {
+	tasks = /* @__PURE__ */ new Map();
+	nodes = /* @__PURE__ */ new Map();
+	nodeOrder = [];
+	nodeByDigest = /* @__PURE__ */ new Map();
+	edges = /* @__PURE__ */ new Map();
+	edgeOrder = [];
+	cells = /* @__PURE__ */ new Map();
+	operations = /* @__PURE__ */ new Map();
+	node(nodeId) {
+		const record = this.nodes.get(nodeId);
+		return record ? nodeView(record) : void 0;
+	}
+	nodeIds() {
+		return this.nodeOrder;
+	}
+	hasNode(nodeId) {
+		return this.nodes.has(nodeId);
+	}
+	nodeIdForDigest(artifactDigest) {
+		return this.nodeByDigest.get(artifactDigest);
+	}
+	edge(edgeId) {
+		return this.edges.get(edgeId);
+	}
+	edgeIds() {
+		return this.edgeOrder;
+	}
+	cell(cellId) {
+		const cell = this.cells.get(cellId);
+		return cell ? { ...cell } : void 0;
+	}
+	cellIds(nodeId) {
+		if (nodeId === void 0) return [...this.cells.keys()];
+		return this.nodes.get(nodeId)?.cellIds ?? [];
+	}
+	operation(operationId) {
+		const operation = this.operations.get(operationId);
+		return operation ? { ...operation } : void 0;
+	}
+	scoredCells(nodeId, split) {
+		const scored = [];
+		for (const cellId of this.nodes.get(nodeId)?.cellIds ?? []) {
+			const cell = this.cells.get(cellId);
+			if (cell.split === split && cell.score !== null) scored.push({
+				cellId,
+				unitId: cell.unitId,
+				attempt: cell.attempts,
+				score: cell.score
+			});
+		}
+		return scored;
+	}
+};
+function nodeView(record) {
+	const latest = record.decisions.at(-1)?.decision ?? null;
+	return {
+		nodeId: record.event.nodeId,
+		ordinal: record.ordinal,
+		artifactDigest: record.event.artifactDigest,
+		artifact: record.event.artifact,
+		surfaces: record.event.surfaces,
+		primaryParentId: record.primaryParentId,
+		depth: record.depth,
+		parents: [...record.parents],
+		children: [...record.children],
+		edgeIds: [...record.edgeIds],
+		status: latest?.status ?? null,
+		rung: latest?.status === "advanced" ? latest.rung : null,
+		finalist: record.finalist,
+		decisions: [...record.decisions],
+		cellCount: record.cellIds.length,
+		spend: { ...record.spend },
+		registeredSequence: record.registeredSequence,
+		updatedSequence: record.updatedSequence
+	};
+}
+//#endregion
+//#region src/campaign/search-state-spend.ts
+/** Spend bookkeeping of a search ledger: the running totals, holds and the claim reserve. */
+/** A cell's share of the open reservations, its overspend, and what it draws
+* from the claim reserve: the larger of its hold and its spend. */
+function reservationParts(cell) {
+	const reserved = cell.reservation?.usd ?? 0;
+	const holding = !cell.final && cell.cancelled === null;
+	return {
+		open: holding ? Math.max(0, reserved - cell.spentUsd) : 0,
+		over: cell.reservation ? Math.max(0, cell.spentUsd - reserved) : 0,
+		used: holding ? Math.max(reserved, cell.spentUsd) : cell.spentUsd
+	};
+}
+/** Writes the spend, token and reservation totals of the audit it is given. */
+var SearchSpendBook = class {
+	audit;
+	claimUsedUsd = 0;
+	constructor(audit) {
+		this.audit = audit;
+	}
+	/** Book an attempt's or operation's accounting into the running totals. An
+	* unknown cost counts as its proven floor. */
+	book(accounting) {
+		const { tokens, cost } = accounting;
+		if (tokens.status === "known") {
+			this.audit.tokens.inputTokens += tokens.inputTokens;
+			this.audit.tokens.outputTokens += tokens.outputTokens;
+			this.audit.tokens.cachedTokens += tokens.cachedTokens;
+		} else this.audit.tokens.unknownTokenAttempts += 1;
+		const usd = cost.status === "known" ? cost.usd : cost.knownLowerBoundUsd;
+		if (cost.status === "known") this.audit.spend.knownUsd += usd;
+		else this.audit.spend.floorUsd += usd;
+		this.audit.spend.committedUsd += usd;
+		return {
+			usd,
+			unknown: cost.status === "unknown"
+		};
+	}
+	/** A new claim cell's hold counts against the claim reserve. */
+	drawClaim(reservation) {
+		this.claimUsedUsd += reservation?.usd ?? 0;
+	}
+	/** Move the audit's open holds, overspend and claim draw from a cell's
+	* `before` shares to its current ones. */
+	shiftHolds(cell, before) {
+		const after = reservationParts(cell);
+		this.audit.spend.openReservationUsd += after.open - before.open;
+		this.audit.spend.overspendUsd += after.over - before.over;
+		if (cell.stage === "claim") this.claimUsedUsd += after.used - before.used;
+	}
+	/** The admission rule: committed spend, open holds, the unspent claim
+	* reserve and the new hold stay within the cap. A claim cell draws on the
+	* claim reserve instead of adding to it.
+	*
+	* The rule admits holds, not records. Spend above a hold is legal
+	* overspend, so committed spend can pass the cap; an event that holds
+	* nothing (the claim operation, a cell an external optimizer already ran)
+	* and a claim cell the unspent reserve covers are then still admitted. The
+	* reserve was set aside at the start and overspend elsewhere cannot take it
+	* back; refusing them would leave a search that can never close. */
+	admit(budget, reservation, claim, subject) {
+		const { maxUsd, reservedClaimUsd } = budget;
+		const hold = reservation?.usd ?? 0;
+		if (maxUsd === null || hold === 0) return;
+		const remainingClaim = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
+		if (claim && hold <= remainingClaim + 1e-9) return;
+		if (this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + (claim ? 0 : remainingClaim) + hold > maxUsd + 1e-9) throw integrity(`${subject} is not admissible: committed $${roundDecimal(this.audit.spend.committedUsd, 6)} + open $${roundDecimal(this.audit.spend.openReservationUsd, 6)} + claim reserve $${roundDecimal(remainingClaim, 6)} + hold $${roundDecimal(hold, 6)} exceeds the cap $${maxUsd}`);
+	}
+	/** The largest hold a new non-claim cell or operation may take, and the
+	* claim reserve still unspent. */
+	room(budget) {
+		const { maxUsd, reservedClaimUsd } = budget ?? {
+			maxUsd: null,
+			reservedClaimUsd: 0
+		};
+		const claimReserveUsd = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
+		if (maxUsd === null) return {
+			headroomUsd: null,
+			claimReserveUsd
+		};
+		const used = this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + claimReserveUsd;
+		return {
+			headroomUsd: Math.max(0, maxUsd - used),
+			claimReserveUsd
+		};
+	}
+};
+//#endregion
 //#region src/campaign/search-state-view.ts
 /** Position-bound search snapshots and deterministic scored-unit reads. */
 /**
@@ -115,12 +282,13 @@ var SearchStateView = class {
 		this.state = state;
 		this.version = version;
 		this.searchId = state.searchId;
-		this.header = state.readHeader();
-		this.closed = state.readClosed();
-		this.head = state.readHead();
-		this.lastOccurredAt = state.readLastOccurredAt();
-		this.audit = state.readAudit();
-		this.budget = state.readBudget();
+		const position = state.readPosition();
+		this.header = position.header;
+		this.closed = position.closed;
+		this.head = position.head;
+		this.lastOccurredAt = position.lastOccurredAt;
+		this.audit = position.audit;
+		this.budget = position.budget;
 		const reasons = state.incompleteReasons();
 		if (!this.closed) reasons.unshift("search is open");
 		this.completion = {
@@ -130,49 +298,49 @@ var SearchStateView = class {
 	}
 	/** The node the search started from: the first registered. */
 	get rootNodeId() {
-		return this.live().readNodeIds()[0] ?? null;
+		return this.live().nodeIds()[0] ?? null;
 	}
 	node(nodeId) {
-		return this.live().readNode(nodeId);
+		return this.live().node(nodeId);
 	}
 	hasNode(nodeId) {
-		return this.live().readHasNode(nodeId);
+		return this.live().hasNode(nodeId);
 	}
 	/** Node ids in registration order. */
 	nodeIds() {
-		return [...this.live().readNodeIds()];
+		return [...this.live().nodeIds()];
 	}
 	/** Nodes in registration order. */
 	nodes() {
 		const state = this.live();
-		return state.readNodeIds().map((nodeId) => state.readNode(nodeId));
+		return state.nodeIds().map((nodeId) => state.node(nodeId));
 	}
 	nodeIdForDigest(artifactDigest) {
-		return this.live().readNodeIdForDigest(artifactDigest);
+		return this.live().nodeIdForDigest(artifactDigest);
 	}
 	edge(edgeId) {
-		return this.live().readEdge(edgeId);
+		return this.live().edge(edgeId);
 	}
 	/** Edges in ledger order. */
 	edges() {
 		const state = this.live();
-		return state.readEdgeIds().map((edgeId) => state.readEdge(edgeId));
+		return state.edgeIds().map((edgeId) => state.edge(edgeId));
 	}
 	cell(cellId) {
-		return this.live().readCell(cellId);
+		return this.live().cell(cellId);
 	}
 	/** Cells in allocation order, optionally of one node. */
 	cells(filter = {}) {
 		const state = this.live();
-		return state.readCellIds(filter.nodeId).map((cellId) => state.readCell(cellId));
+		return state.cellIds(filter.nodeId).map((cellId) => state.cell(cellId));
 	}
 	operation(operationId) {
-		return this.live().readOperation(operationId);
+		return this.live().operation(operationId);
 	}
 	/** A node's scored cells on one split, in allocation order. Unscored cells
 	* (errored, cancelled or in flight) are absent, never zero. */
 	scoredCells(nodeId, split) {
-		return this.live().readScoredCells(nodeId, split);
+		return this.live().scoredCells(nodeId, split);
 	}
 	/** Per-unit score means of a node on one split, in unitId order. */
 	unitScores(nodeId, split) {
@@ -182,10 +350,10 @@ var SearchStateView = class {
 	lineage(coordinates) {
 		const state = this.live();
 		if (coordinates.searchId !== this.searchId) throw new SearchLedgerError(`coordinates name search ${coordinates.searchId}, not ${this.searchId}`);
-		const cell = state.readCell(coordinates.cellId);
+		const cell = state.cell(coordinates.cellId);
 		if (!cell || cell.nodeId !== coordinates.nodeId) throw new SearchLedgerError(`cell ${coordinates.cellId} of node ${coordinates.nodeId} is not in search ${this.searchId}`);
 		if (coordinates.attempt < 1 || coordinates.attempt > cell.attempts) throw new SearchLedgerError(`cell ${coordinates.cellId} has ${cell.attempts} settled attempt(s), not attempt ${coordinates.attempt}`);
-		const node = state.readNode(cell.nodeId);
+		const node = state.node(cell.nodeId);
 		if (node.depth === null) throw new SearchLedgerError(`node ${node.nodeId} has unknown lineage, so its depth is unknown`);
 		const containment = this.header?.containment ?? null;
 		return {
@@ -200,32 +368,9 @@ var SearchStateView = class {
 	}
 	live() {
 		if (!this.state.isAt(this.version)) throw new SearchLedgerError(`this SearchStateView is from sequence ${this.head?.sequence ?? -1}, and the ledger has moved on; read the ledger's state again`);
-		return this.state;
+		return this.state.index;
 	}
 };
-function nodeView(record) {
-	const latest = record.decisions.at(-1)?.decision ?? null;
-	return {
-		nodeId: record.event.nodeId,
-		ordinal: record.ordinal,
-		artifactDigest: record.event.artifactDigest,
-		artifact: record.event.artifact,
-		surfaces: record.event.surfaces,
-		primaryParentId: record.primaryParentId,
-		depth: record.depth,
-		parents: [...record.parents],
-		children: [...record.children],
-		edgeIds: [...record.edgeIds],
-		status: latest?.status ?? null,
-		rung: latest?.status === "advanced" ? latest.rung : null,
-		finalist: record.finalist,
-		decisions: [...record.decisions],
-		cellCount: record.cellIds.length,
-		spend: { ...record.spend },
-		registeredSequence: record.registeredSequence,
-		updatedSequence: record.updatedSequence
-	};
-}
 //#endregion
 //#region src/campaign/search-state-projection.ts
 const SPLITS = [
@@ -246,21 +391,15 @@ var SearchState = class {
 	head = null;
 	lastOccurredAt = Number.NEGATIVE_INFINITY;
 	lastOccurredAtText = null;
-	tasks = /* @__PURE__ */ new Map();
-	nodes = /* @__PURE__ */ new Map();
-	nodeOrder = [];
-	nodeByDigest = /* @__PURE__ */ new Map();
-	edges = /* @__PURE__ */ new Map();
-	edgeOrder = [];
-	cells = /* @__PURE__ */ new Map();
-	operations = /* @__PURE__ */ new Map();
 	selectedNodeId = null;
-	claimUsedUsd = 0;
 	/** Nodes ever decided `finalist`. */
 	finalists = /* @__PURE__ */ new Set();
 	/** Claim cells allocated. Once one exists, the finalists are fixed. */
 	claimCells = 0;
 	audit;
+	spend;
+	/** @internal The live indexes a `SearchStateView` reads. */
+	index = new SearchLedgerIndexes();
 	constructor(searchId) {
 		this.searchId = searchId;
 		this.audit = {
@@ -314,6 +453,7 @@ var SearchState = class {
 				unknownTokenAttempts: 0
 			}
 		};
+		this.spend = new SearchSpendBook(this.audit);
 	}
 	apply(entry, index) {
 		const event = entry.event;
@@ -388,9 +528,9 @@ var SearchState = class {
 			const { tasks, taskSetDigest } = event.splits[split];
 			if (searchTaskSetDigest(tasks) !== taskSetDigest) throw integrity(`the ${split} split's taskSetDigest does not match its tasks`);
 			for (const task of tasks) {
-				const owner = this.tasks.get(task.taskId);
+				const owner = this.index.tasks.get(task.taskId);
 				if (owner) throw integrity(`task ${task.taskId} is in both the ${owner.split} and ${split} splits`);
-				this.tasks.set(task.taskId, {
+				this.index.tasks.set(task.taskId, {
 					split,
 					unitId: task.unitId
 				});
@@ -406,10 +546,10 @@ var SearchState = class {
 		this.header = event;
 	}
 	startOperation(event) {
-		if (this.operations.has(event.operationId)) throw integrity(`operation ${event.operationId} was started twice`);
+		if (this.index.operations.has(event.operationId)) throw integrity(`operation ${event.operationId} was started twice`);
 		this.assertSearching(`operation ${event.operationId}`);
-		this.admit(event.reservation, false, `operation ${event.operationId}`);
-		this.operations.set(event.operationId, {
+		this.spend.admit(this.header.budget, event.reservation, false, `operation ${event.operationId}`);
+		this.index.operations.set(event.operationId, {
 			operationId: event.operationId,
 			operationKind: event.operationKind,
 			reservation: event.reservation,
@@ -425,11 +565,11 @@ var SearchState = class {
 		this.audit.spend.openReservationUsd += event.reservation?.usd ?? 0;
 	}
 	recordOperation(event) {
-		const operation = this.operations.get(event.operationId);
+		const operation = this.index.operations.get(event.operationId);
 		if (!operation) throw integrity(`operation ${event.operationId} was recorded before it started`);
 		if (operation.recorded) throw integrity(`operation ${event.operationId} was recorded twice`);
 		if (operation.operationKind !== event.operationKind) throw integrity(`operation ${event.operationId} started as ${operation.operationKind} but recorded as ${event.operationKind}`);
-		const cost = this.book(event.accounting);
+		const cost = this.spend.book(event.accounting);
 		if (cost.unknown) this.audit.spend.unknownCostOperations += 1;
 		const reserved = operation.reservation?.usd ?? 0;
 		this.audit.spend.openReservationUsd -= reserved;
@@ -446,14 +586,14 @@ var SearchState = class {
 	registerNode(event, index) {
 		const expected = searchNodeId(this.searchId, event.artifactDigest);
 		if (event.nodeId !== expected) throw integrity(`node ${event.nodeId} does not match its artifact digest (expected ${expected})`);
-		if (this.nodes.has(event.nodeId)) throw integrity(`node ${event.nodeId} was registered twice; a re-proposal is a second edge into it`);
+		if (this.index.nodes.has(event.nodeId)) throw integrity(`node ${event.nodeId} was registered twice; a re-proposal is a second edge into it`);
 		this.assertSearching(`node ${event.nodeId}`);
 		assertUnique(event.surfaces.map((surface) => surface.surfaceId), "surfaceId", event.eventId);
 		const maxNodes = this.header.budget.maxNodes;
-		if (maxNodes !== null && this.nodes.size + 1 > maxNodes) throw integrity(`node ${event.nodeId} exceeds the search's maxNodes ${maxNodes}`);
-		this.nodes.set(event.nodeId, {
+		if (maxNodes !== null && this.index.nodes.size + 1 > maxNodes) throw integrity(`node ${event.nodeId} exceeds the search's maxNodes ${maxNodes}`);
+		this.index.nodes.set(event.nodeId, {
 			event,
-			ordinal: this.nodeOrder.length,
+			ordinal: this.index.nodeOrder.length,
 			registeredSequence: index,
 			updatedSequence: index,
 			edgeIds: [],
@@ -473,15 +613,15 @@ var SearchState = class {
 				boxMinutes: 0
 			}
 		});
-		this.nodeOrder.push(event.nodeId);
-		this.nodeByDigest.set(event.artifactDigest, event.nodeId);
+		this.index.nodeOrder.push(event.nodeId);
+		this.index.nodeByDigest.set(event.artifactDigest, event.nodeId);
 		this.audit.nodes += 1;
 		this.audit.nodesWithoutEdge += 1;
 		this.audit.undecidedNodes += 1;
 	}
 	recordEdge(event, index) {
-		if (this.edges.has(event.edgeId)) throw integrity(`edge ${event.edgeId} was recorded twice`);
-		const child = this.nodes.get(event.childNodeId);
+		if (this.index.edges.has(event.edgeId)) throw integrity(`edge ${event.edgeId} was recorded twice`);
+		const child = this.index.nodes.get(event.childNodeId);
 		if (!child) throw integrity(`edge ${event.edgeId} names unregistered child ${event.childNodeId}`);
 		this.assertSearching(`edge ${event.edgeId}`);
 		if (event.label.length > 200) throw integrity(`edge ${event.edgeId} label exceeds 200 characters`);
@@ -494,7 +634,7 @@ var SearchState = class {
 		if (operator !== "seed" && attribution !== "unknown" && parents.length === 0) throw integrity(`${operator} edge ${event.edgeId} names no parent`);
 		if (operator === "merge" && attribution !== "unknown" && parents.length < 2) throw integrity(`merge edge ${event.edgeId} needs at least two parents`);
 		const operationId = event.proposer?.operationId ?? null;
-		if (operationId !== null && !this.operations.has(operationId)) throw integrity(`edge ${event.edgeId} names operation ${operationId}, which never started`);
+		if (operationId !== null && !this.index.operations.has(operationId)) throw integrity(`edge ${event.edgeId} names operation ${operationId}, which never started`);
 		const reproposal = child.edgeIds.length > 0;
 		const inSearch = [];
 		const later = /* @__PURE__ */ new Set();
@@ -505,7 +645,7 @@ var SearchState = class {
 				continue;
 			}
 			if (operator === "derive") throw integrity(`derive edge ${event.edgeId} must name the parent in derivedFrom`);
-			const record = this.nodes.get(parent.nodeId);
+			const record = this.index.nodes.get(parent.nodeId);
 			if (!record) throw integrity(`edge ${event.edgeId} names unregistered parent ${parent.nodeId}`);
 			if (record.ordinal >= child.ordinal && !reproposal) throw integrity(`edge ${event.edgeId}: parent ${parent.nodeId} registered after child ${child.event.nodeId}`);
 			if (record.edgeIds.length === 0) throw integrity(`edge ${event.edgeId}: parent ${parent.nodeId} has no edge of its own yet`);
@@ -528,18 +668,18 @@ var SearchState = class {
 		}
 		for (const parent of inSearch) if (!parent.children.includes(child.event.nodeId)) parent.children.push(child.event.nodeId);
 		child.updatedSequence = index;
-		this.edges.set(event.edgeId, event);
-		this.edgeOrder.push(event.edgeId);
+		this.index.edges.set(event.edgeId, event);
+		this.index.edgeOrder.push(event.edgeId);
 		this.audit.edges[attribution] += 1;
 	}
 	allocateCell(event, index) {
 		const expected = searchCellId(this.searchId, event.nodeId, event.taskId, event.split, event.rep);
 		if (event.cellId !== expected) throw integrity(`cell ${event.cellId} does not match its coordinates (expected ${expected})`);
-		if (this.cells.has(event.cellId)) throw integrity(`cell ${event.cellId} was allocated twice`);
-		const node = this.nodes.get(event.nodeId);
+		if (this.index.cells.has(event.cellId)) throw integrity(`cell ${event.cellId} was allocated twice`);
+		const node = this.index.nodes.get(event.nodeId);
 		if (!node) throw integrity(`cell ${event.cellId} names unregistered node ${event.nodeId}`);
 		if (node.edgeIds.length === 0) throw integrity(`cell ${event.cellId}: node ${event.nodeId} has no edge yet`);
-		const task = this.tasks.get(event.taskId);
+		const task = this.index.tasks.get(event.taskId);
 		if (!task || task.split !== event.split) throw integrity(`cell ${event.cellId}: task ${event.taskId} is not in the ${event.split} split`);
 		if (task.unitId !== event.unitId) throw integrity(`cell ${event.cellId}: task ${event.taskId} samples unit ${task.unitId}`);
 		assertStageSplit(event.cellId, event.stage, event.split, node.ordinal === 0);
@@ -547,8 +687,8 @@ var SearchState = class {
 		if (event.stage !== "claim") this.assertSearching(`cell ${event.cellId}`);
 		const maxCells = this.header.budget.maxCells;
 		if (maxCells !== null && this.audit.cells.allocated + 1 > maxCells) throw integrity(`cell ${event.cellId} exceeds the search's maxCells ${maxCells}`);
-		this.admit(event.reservation, event.stage === "claim", `cell ${event.cellId}`);
-		this.cells.set(event.cellId, {
+		this.spend.admit(this.header.budget, event.reservation, event.stage === "claim", `cell ${event.cellId}`);
+		this.index.cells.set(event.cellId, {
 			cellId: event.cellId,
 			nodeId: event.nodeId,
 			taskId: event.taskId,
@@ -576,12 +716,12 @@ var SearchState = class {
 		this.audit.cells.open += 1;
 		this.audit.spend.openReservationUsd += event.reservation?.usd ?? 0;
 		if (event.stage === "claim") {
-			this.claimUsedUsd += event.reservation?.usd ?? 0;
+			this.spend.drawClaim(event.reservation);
 			this.claimCells += 1;
 		}
 	}
 	settleCell(event, index) {
-		const cell = this.cells.get(event.cellId);
+		const cell = this.index.cells.get(event.cellId);
 		if (!cell) throw integrity(`attempt ${event.eventId} names unallocated cell ${event.cellId}`);
 		if (cell.cancelled) throw integrity(`cell ${event.cellId} was settled after it was cancelled`);
 		if (cell.final) throw integrity(`cell ${event.cellId} was attempted again after a final ${cell.outcome} outcome; only a retryable error admits another attempt`);
@@ -591,13 +731,13 @@ var SearchState = class {
 			attempt: event.attempt
 		});
 		if (event.runId !== runId) throw integrity(`cell ${event.cellId} attempt ${event.attempt} must have runId ${runId}`);
-		const node = this.nodes.get(cell.nodeId);
+		const node = this.index.nodes.get(cell.nodeId);
 		const declared = new Set(node.event.surfaces.map((surface) => surface.surfaceId));
 		assertUnique(event.surfaceEvidence.map((evidence) => evidence.surfaceId), "surface evidence", event.eventId);
 		for (const evidence of event.surfaceEvidence) if (!declared.has(evidence.surfaceId)) throw integrity(`attempt ${event.eventId} reports surface ${evidence.surfaceId}, which node ${cell.nodeId} does not declare`);
 		if (event.artifacts.filter((artifact) => artifact.role === "run-record").length > 1) throw integrity(`attempt ${event.eventId} binds more than one RunRecord`);
-		const before = this.reservationParts(cell);
-		const cost = this.book(event.accounting);
+		const before = reservationParts(cell);
+		const cost = this.spend.book(event.accounting);
 		if (cell.attempts === 0) {
 			this.audit.cells.settled += 1;
 			this.audit.cells.open -= 1;
@@ -620,10 +760,7 @@ var SearchState = class {
 			cell.score = event.outcome.score;
 			node.scoredCells += 1;
 		}
-		const after = this.reservationParts(cell);
-		this.audit.spend.openReservationUsd += after.open - before.open;
-		this.audit.spend.overspendUsd += after.over - before.over;
-		if (cell.stage === "claim") this.claimUsedUsd += after.used - before.used;
+		this.spend.shiftHolds(cell, before);
 		if (cost.unknown) node.spend.floorUsd += cost.usd;
 		else node.spend.knownUsd += cost.usd;
 		const boxMinutes = event.boxMinutes ?? 0;
@@ -634,25 +771,22 @@ var SearchState = class {
 		this.audit.outcomes[event.outcome.status] += 1;
 	}
 	cancelCell(event, index) {
-		const cell = this.cells.get(event.cellId);
+		const cell = this.index.cells.get(event.cellId);
 		if (!cell) throw integrity(`cancellation ${event.eventId} names unallocated cell ${event.cellId}`);
 		if (cell.cancelled) throw integrity(`cell ${event.cellId} was cancelled twice`);
 		if (cell.final) throw integrity(`cell ${event.cellId} was cancelled after a final outcome`);
-		const before = this.reservationParts(cell);
+		const before = reservationParts(cell);
 		cell.cancelled = event.reason;
 		cell.updatedSequence = index;
-		const after = this.reservationParts(cell);
-		this.audit.spend.openReservationUsd += after.open - before.open;
-		this.audit.spend.overspendUsd += after.over - before.over;
-		if (cell.stage === "claim") this.claimUsedUsd += after.used - before.used;
+		this.spend.shiftHolds(cell, before);
 		if (cell.attempts === 0) {
 			this.audit.cells.cancelled += 1;
 			this.audit.cells.open -= 1;
 		}
-		this.nodes.get(cell.nodeId).updatedSequence = index;
+		this.index.nodes.get(cell.nodeId).updatedSequence = index;
 	}
 	decideNode(event, index) {
-		const node = this.nodes.get(event.nodeId);
+		const node = this.index.nodes.get(event.nodeId);
 		if (!node) throw integrity(`decision ${event.eventId} names unregistered node ${event.nodeId}`);
 		if (node.edgeIds.length === 0) throw integrity(`decision ${event.eventId}: node ${event.nodeId} has no edge yet`);
 		const status = event.decision.status;
@@ -697,7 +831,7 @@ var SearchState = class {
 		assertUnique(named, "claim finalist", "search-closed");
 		for (const nodeId of named) if (!this.finalists.has(nodeId)) throw integrity(`claim finalist ${nodeId} was never decided finalist`);
 		for (const nodeId of this.finalists) if (!named.includes(nodeId)) throw integrity(`finalist ${nodeId} is missing from the claim`);
-		const root = this.nodeOrder[0] ?? null;
+		const root = this.index.nodeOrder[0] ?? null;
 		const perFinalist = 1 - (1 - claim.confidence) / Math.max(1, named.length);
 		for (const finalist of claim.finalists) {
 			const { estimate, test } = finalist;
@@ -713,13 +847,13 @@ var SearchState = class {
 			if ("unknown" in this.header.objective.judge) throw integrity("a ship claim needs a pinned judge; with an unknown judge a resumed search could mix two judges' verdicts");
 			const testUnits = new Set(this.header.splits.test.tasks.map((task) => task.unitId));
 			for (const nodeId of [root, claim.selected]) {
-				const scored = new Set(this.readScoredCells(nodeId, "test").map((cell) => cell.unitId));
+				const scored = new Set(this.index.scoredCells(nodeId, "test").map((cell) => cell.unitId));
 				const missing = [...testUnits].filter((unit) => !scored.has(unit));
 				if (missing.length > 0) throw integrity(`a ship claim needs every test unit scored by the root and the finalist; ${nodeId} has none on ${missing.join(", ")}`);
 			}
 		} else if (claim.selected !== null && claim.selected !== root) throw integrity(`a ${claim.decision} claim keeps the root; it cannot select another node`);
 		if (claim.decision === "test-cannot-resolve") {
-			for (const cell of this.cells.values()) if (cell.split === "test" && cell.attempts > 0) throw integrity("a test-cannot-resolve claim spends nothing on test cells");
+			for (const cell of this.index.cells.values()) if (cell.split === "test" && cell.attempts > 0) throw integrity("a test-cannot-resolve claim spends nothing on test cells");
 		}
 	}
 	/** Once the first finalist is decided, the search only runs its claim:
@@ -737,154 +871,27 @@ var SearchState = class {
 		if (this.audit.undecidedNodes > 0) reasons.push(count(this.audit.undecidedNodes, "node", "has no terminal decision"));
 		return reasons;
 	}
-	/** Book an attempt's or operation's accounting into the running totals. An
-	* unknown cost counts as its proven floor. */
-	book(accounting) {
-		const { tokens, cost } = accounting;
-		if (tokens.status === "known") {
-			this.audit.tokens.inputTokens += tokens.inputTokens;
-			this.audit.tokens.outputTokens += tokens.outputTokens;
-			this.audit.tokens.cachedTokens += tokens.cachedTokens;
-		} else this.audit.tokens.unknownTokenAttempts += 1;
-		const usd = cost.status === "known" ? cost.usd : cost.knownLowerBoundUsd;
-		if (cost.status === "known") this.audit.spend.knownUsd += usd;
-		else this.audit.spend.floorUsd += usd;
-		this.audit.spend.committedUsd += usd;
-		return {
-			usd,
-			unknown: cost.status === "unknown"
-		};
-	}
-	/** A cell's share of the open reservations, its overspend, and what it draws
-	* from the claim reserve: the larger of its hold and its spend. */
-	reservationParts(cell) {
-		const reserved = cell.reservation?.usd ?? 0;
-		const holding = !cell.final && cell.cancelled === null;
-		return {
-			open: holding ? Math.max(0, reserved - cell.spentUsd) : 0,
-			over: cell.reservation ? Math.max(0, cell.spentUsd - reserved) : 0,
-			used: holding ? Math.max(reserved, cell.spentUsd) : cell.spentUsd
-		};
-	}
-	/** The admission rule: committed spend, open holds, the unspent claim
-	* reserve and the new hold stay within the cap. A claim cell draws on the
-	* claim reserve instead of adding to it.
-	*
-	* The rule admits holds, not records. Spend above a hold is legal
-	* overspend, so committed spend can pass the cap; an event that holds
-	* nothing (the claim operation, a cell an external optimizer already ran)
-	* and a claim cell the unspent reserve covers are then still admitted. The
-	* reserve was set aside at the start and overspend elsewhere cannot take it
-	* back; refusing them would leave a search that can never close. */
-	admit(reservation, claim, subject) {
-		const { maxUsd, reservedClaimUsd } = this.header.budget;
-		const hold = reservation?.usd ?? 0;
-		if (maxUsd === null || hold === 0) return;
-		const remainingClaim = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
-		if (claim && hold <= remainingClaim + 1e-9) return;
-		if (this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + (claim ? 0 : remainingClaim) + hold > maxUsd + 1e-9) throw integrity(`${subject} is not admissible: committed $${roundDecimal(this.audit.spend.committedUsd, 6)} + open $${roundDecimal(this.audit.spend.openReservationUsd, 6)} + claim reserve $${roundDecimal(remainingClaim, 6)} + hold $${roundDecimal(hold, 6)} exceeds the cap $${maxUsd}`);
-	}
-	/** @internal The largest hold a new non-claim cell or operation may take,
-	* and the claim reserve still unspent. */
-	readBudget() {
-		const { maxUsd, reservedClaimUsd } = this.header?.budget ?? {
-			maxUsd: null,
-			reservedClaimUsd: 0
-		};
-		const claimReserveUsd = Math.max(0, reservedClaimUsd - this.claimUsedUsd);
-		if (maxUsd === null) return {
-			headroomUsd: null,
-			claimReserveUsd
-		};
-		const used = this.audit.spend.committedUsd + this.audit.spend.openReservationUsd + claimReserveUsd;
-		return {
-			headroomUsd: Math.max(0, maxUsd - used),
-			claimReserveUsd
-		};
-	}
-	/** @internal */
-	readHeader() {
-		return this.header;
-	}
-	/** @internal */
-	readClosed() {
-		return this.closed;
-	}
-	/** @internal */
-	readHead() {
-		return this.head;
-	}
-	/** @internal */
-	readLastOccurredAt() {
-		return this.lastOccurredAtText;
-	}
-	/** @internal */
-	readAudit() {
+	/** @internal What a `SearchStateView` copies at construction: the header,
+	* close, head and last timestamp, a snapshot of the audit, and the budget room. */
+	readPosition() {
 		const audit = this.audit;
 		return {
-			...audit,
-			edges: { ...audit.edges },
-			cells: { ...audit.cells },
-			outcomes: { ...audit.outcomes },
-			operations: { ...audit.operations },
-			spend: { ...audit.spend },
-			tokens: { ...audit.tokens }
+			header: this.header,
+			closed: this.closed,
+			head: this.head,
+			lastOccurredAt: this.lastOccurredAtText,
+			audit: {
+				...audit,
+				edges: { ...audit.edges },
+				cells: { ...audit.cells },
+				outcomes: { ...audit.outcomes },
+				operations: { ...audit.operations },
+				spend: { ...audit.spend },
+				tokens: { ...audit.tokens }
+			},
+			budget: this.spend.room(this.header?.budget)
 		};
 	}
-	/** @internal */
-	readNode(nodeId) {
-		const record = this.nodes.get(nodeId);
-		return record ? nodeView(record) : void 0;
-	}
-	/** @internal */
-	readNodeIds() {
-		return this.nodeOrder;
-	}
-	/** @internal */
-	readHasNode(nodeId) {
-		return this.nodes.has(nodeId);
-	}
-	/** @internal */
-	readNodeIdForDigest(artifactDigest) {
-		return this.nodeByDigest.get(artifactDigest);
-	}
-	/** @internal */
-	readEdge(edgeId) {
-		return this.edges.get(edgeId);
-	}
-	/** @internal */
-	readEdgeIds() {
-		return this.edgeOrder;
-	}
-	/** @internal */
-	readCell(cellId) {
-		const cell = this.cells.get(cellId);
-		return cell ? { ...cell } : void 0;
-	}
-	/** @internal */
-	readCellIds(nodeId) {
-		if (nodeId === void 0) return [...this.cells.keys()];
-		return this.nodes.get(nodeId)?.cellIds ?? [];
-	}
-	/** @internal */
-	readOperation(operationId) {
-		const operation = this.operations.get(operationId);
-		return operation ? { ...operation } : void 0;
-	}
-	/** @internal */
-	readScoredCells(nodeId, split) {
-		const scored = [];
-		for (const cellId of this.nodes.get(nodeId)?.cellIds ?? []) {
-			const cell = this.cells.get(cellId);
-			if (cell.split === split && cell.score !== null) scored.push({
-				cellId,
-				unitId: cell.unitId,
-				attempt: cell.attempts,
-				score: cell.score
-			});
-		}
-		return scored;
-	}
 };
 function count(value, noun, predicate) {
 	const verb = predicate.replace(/^(has|is) /, (word) => value === 1 ? word : word === "has " ? "have " : "are ");
@@ -1582,4 +1589,4 @@ function formatZodError(error) {
 //#endregion
 export { validateSearchLedgerEvent as a, SearchStateView as c, searchNodeId as d, searchTaskSetDigest as f, replaySearchLedgerText as i, searchUnitScores as l, openSearchLedger as n, SEARCH_LEDGER_SCHEMA as o, USD_TOLERANCE as p, parseSearchLedgerLine as r, SearchState as s, FileSearchLedger as t, searchCellId as u };
 
-//# sourceMappingURL=search-ledger-ClpN4I3e.js.map
+//# sourceMappingURL=search-ledger-CZRqtFbW.js.map