@rulvar/core 1.241.0 → 1.243.0

package/dist/index.js

@@ -7972,6 +7972,7 @@ var Replayer = class {
 			if (patch.evidence !== void 0) entry.evidence = patch.evidence;
 			if (patch.evidenceEntries !== void 0) entry.evidenceEntries = patch.evidenceEntries;
 			if (patch.toolBudget !== void 0) entry.toolBudget = patch.toolBudget;
+			if (patch.hostRejected !== void 0) entry.hostRejected = patch.hostRejected;
 			if (patch.artifacts !== void 0) entry.artifacts = toJournalValue(patch.artifacts, "terminal artifacts");
 			if (patch.escalation !== void 0) entry.escalation = toJournalValue(patch.escalation, "escalation report");
 			if (patch.memoizeOutcome !== void 0) entry.memoizeOutcome = patch.memoizeOutcome;
@@ -9311,6 +9312,7 @@ function reduceInvocationTable(events) {
 			row.usageApprox = event.usageApprox === true;
 			row.retryCount = event.retryCount ?? 0;
 			if (event.toolBudget !== void 0) row.toolBudget = event.toolBudget;
+			if (event.hostRejected === true) row.hostRejected = true;
 			totalCostUsd += event.costUsd;
 			break;
 		}
@@ -9331,6 +9333,20 @@ function reduceInvocationTable(events) {
 */
 const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
 /**
+* The live abort reason of a finish rejection (RV3702): the value
+* `orchestrate()` aborts a composition invocation's signal with when
+* the declared finish contract rejects its candidate past the repair
+* bound, and ONLY then; a defective (throwing) validator aborts with
+* its own distinct reason, because a host defect is not a verdict on
+* the candidate. The settle layer reads the reason back and stamps
+* `hostRejected` onto the terminal agent entry and the live
+* `agent:end` event, so both span surfaces can tell a host rejection
+* (wires fine, document refused) from a provider failure without a
+* journal dig; the third comparison run's reader had exactly that
+* span (two successful wires, span cancelled) and nothing to name it.
+*/
+const FINISH_REJECTION_ABORT_REASON = "rulvar:finish-validation";
+/**
 * Whether a synthesize span's label names a claim-consistency judge
 * invocation: the exact {@link CLAIM_JUDGE_LABEL}, or a suffixed
 * variant of it (the final pass dispatches under
@@ -9413,6 +9429,7 @@ function reduceCriticalPath(events) {
 	let finalJudgeMs = 0;
 	let compositionSpans = 0;
 	let judgeSpans = 0;
+	let hostRejectedSpans = 0;
 	let firstCompositionEnd;
 	let lastCompositionEnd;
 	const coordinationModel = [];
@@ -9453,6 +9470,7 @@ function reduceCriticalPath(events) {
 			case "agent:end": {
 				const started = startBySpan.get(event.spanId);
 				if (started === void 0) break;
+				if (event.hostRejected === true) hostRejectedSpans += 1;
 				if (started.role === "synthesize") {
 					const wall = Math.max(0, at - started.at);
 					const stage = claimJudgeStageOf(started.label);
@@ -9491,7 +9509,8 @@ function reduceCriticalPath(events) {
 		finalJudgeMs,
 		compositionSpans,
 		judgeSpans,
-		workerSpans
+		workerSpans,
+		hostRejectedSpans
 	};
 	if (runStart !== void 0 && runEnd !== void 0) path.runWallMs = Math.max(0, runEnd - runStart);
 	if (runStart !== void 0 && firstCompositionEnd !== void 0) path.firstCandidateMs = Math.max(0, firstCompositionEnd - runStart);
@@ -9583,6 +9602,7 @@ function criticalPathFromJournal(entries) {
 	let lastWorkerEnd;
 	let workerSpans = 0;
 	let unclassifiedSpans = 0;
+	let hostRejectedSpans = 0;
 	let synthesisMs = 0;
 	let finalCompositionMs = 0;
 	let semanticJudgeMs = 0;
@@ -9602,6 +9622,7 @@ function criticalPathFromJournal(entries) {
 		const last = endedAt ?? startedAt;
 		if (last !== void 0) runEnd = runEnd === void 0 ? last : Math.max(runEnd, last);
 		if (entry.kind !== "agent" || entry.status === "running" || entry.status === "suspended") continue;
+		if (entry.hostRejected === true) hostRejectedSpans += 1;
 		const role = entry.costAttribution?.role;
 		if (role === void 0) {
 			unclassifiedSpans += 1;
@@ -9649,7 +9670,8 @@ function criticalPathFromJournal(entries) {
 		workerSpans,
 		synthesisMs,
 		unclassifiedSpans,
-		segments
+		segments,
+		hostRejectedSpans
 	};
 	const splitLegible = labelledSynthesis && !unlabelledSynthesis;
 	if (splitLegible) {
@@ -9856,7 +9878,8 @@ function synthesisCandidatesFromJournal(entries, priceUsd) {
 				name: failure.name,
 				reasons: Array.isArray(failure.reasons) ? failure.reasons.filter((reason) => typeof reason === "string") : []
 			})) : [],
-			...span.label === void 0 ? {} : { spanLabel: span.label }
+			...span.label === void 0 ? {} : { spanLabel: span.label },
+			spanSeq: span.runningSeq
 		};
 		if (boundary.at !== void 0 && verdictAtMs !== void 0) candidate.windowMs = Math.max(0, verdictAtMs - boundary.at);
 		if (attributable.has(span)) {
@@ -9889,6 +9912,29 @@ function synthesisCandidatesFromJournal(entries, priceUsd) {
 		tailWires
 	};
 }
+/**
+* The observed price of the run's LAST mechanical repair turn
+* (RV3802): the window of the candidate that FOLLOWED a 'repair'
+* verdict inside the same settled synthesize span, priced by the same
+* per-call fold every candidate window uses. This is the fallback the
+* repair round's mechanical money leg sizes itself from when the host
+* declared no estimate: by the time the round is admitted the initial
+* composition has settled, so a mechanical repair it performed is a
+* priced window in the journal. Fail closed under RV1209: no such
+* pairing, an unattributed span, or an unpriceable window all return
+* undefined (never a guessed number), and the caller treats undefined
+* as an inert zero-size leg.
+*/
+function lastMechanicalRepairCostUsd(entries, priceUsd) {
+	const { candidates } = synthesisCandidatesFromJournal(entries, priceUsd);
+	let observed;
+	for (let index = 1; index < candidates.length; index += 1) {
+		const previous = candidates[index - 1];
+		const row = candidates[index];
+		if (previous?.verdict === "repair" && row?.spanSeq !== void 0 && row.spanSeq === previous.spanSeq && row.costUsd !== void 0) observed = row.costUsd;
+	}
+	return observed;
+}
 //#endregion
 //#region src/stores/tool-calibration.ts
 /**
@@ -14875,6 +14921,8 @@ var RunBudget = class {
 			committedReserveUsd: 0,
 			finalizeReserveUsd: 0,
 			synthesisReserveUsd: 0,
+			convergenceReserveUsd: 0,
+			repairReserveUsd: 0,
 			controller: new AbortController()
 		};
 		if (options.ceilingUsd !== void 0) root.ceilingUsd = options.ceilingUsd;
@@ -14925,6 +14973,8 @@ var RunBudget = class {
 			committedReserveUsd: 0,
 			finalizeReserveUsd: options.finalizeReserveUsd ?? 0,
 			synthesisReserveUsd: 0,
+			convergenceReserveUsd: 0,
+			repairReserveUsd: 0,
 			parentScope,
 			controller: new AbortController()
 		};
@@ -15025,7 +15075,9 @@ var RunBudget = class {
 			spentUsd: account.spentUsd,
 			committedReserveUsd: account.committedReserveUsd,
 			finalizeReserveUsd: account.finalizeReserveUsd,
-			synthesisReserveUsd: account.synthesisReserveUsd
+			synthesisReserveUsd: account.synthesisReserveUsd,
+			convergenceReserveUsd: account.convergenceReserveUsd,
+			repairReserveUsd: account.repairReserveUsd
 		};
 		if (account.ceilingUsd !== void 0) view.ceilingUsd = account.ceilingUsd;
 		if (account.parentScope !== void 0) view.parentScope = account.parentScope;
@@ -15039,7 +15091,7 @@ var RunBudget = class {
 	remainderOf(scope) {
 		const account = this.accounts.get(scope);
 		if (account?.ceilingUsd === void 0) return;
-		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd);
+		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd - account.convergenceReserveUsd - account.repairReserveUsd);
 	}
 	/**
 	* The tightest allowance headroom on the chain of `scope`: the minimum
@@ -15119,15 +15171,17 @@ var RunBudget = class {
 		}
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd;
+			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd + account.convergenceReserveUsd + account.repairReserveUsd;
 			if (committed >= account.ceilingUsd || committed + reserveUsd > account.ceilingUsd) {
 				if (account.scope === "run") this.exhaustedInternal = true;
-				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
+				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + (account.convergenceReserveUsd > 0 ? `plus the held convergence reserve ${account.convergenceReserveUsd.toFixed(4)} USD ` : "") + (account.repairReserveUsd > 0 ? `plus the held repair reserve ${account.repairReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
 					account: account.scope,
 					spentUsd: account.spentUsd,
 					committedReserveUsd: account.committedReserveUsd,
 					finalizeReserveUsd: account.finalizeReserveUsd,
 					synthesisReserveUsd: account.synthesisReserveUsd,
+					convergenceReserveUsd: account.convergenceReserveUsd,
+					repairReserveUsd: account.repairReserveUsd,
 					proposedReserveUsd: reserveUsd,
 					ceilingUsd: account.ceilingUsd
 				} });
@@ -15219,6 +15273,74 @@ var RunBudget = class {
 		account.synthesisReserveUsd = 0;
 		this.emitUpdate();
 	}
+	/**
+	* Registers the repair round's verdict reserve (RV3701, the third
+	* comparison experiment's arc): absolute dollars held on the
+	* orchestrator account AND the run root for the verdict pass (the
+	* round's second judge invocation) that must follow a DISPATCHED
+	* claim repair round. The third comparison run
+	* proved the round's two invocation tail is only as convergent as
+	* the money left when the candidate materializes; with the verdict
+	* money held from the moment the round is admitted, the round's own
+	* repair turns (the layer-2b clamp prices output from a remainder
+	* this hold shrinks) and any concurrent admission (the hold joins
+	* the projected admission sum) cannot eat it, so a round the budget
+	* can only START is refused before any wire call instead of being
+	* paid for and left unjudgeable. Exactly the synthesis reserve
+	* mechanics: released to the invocation it was held FOR (the
+	* verdict pass dispatch), never joined to the severing check.
+	* Idempotent per account: registering again adjusts the root by the
+	* delta.
+	*/
+	commitConvergenceReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the convergence reserve`);
+		const previous = account.convergenceReserveUsd;
+		account.convergenceReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.convergenceReserveUsd = Math.max(0, this.root.convergenceReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The verdict pass dispatch consumes its reserve; see commitConvergenceReserve. */
+	releaseConvergenceReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.convergenceReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.convergenceReserveUsd = Math.max(0, this.root.convergenceReserveUsd - account.convergenceReserveUsd);
+		account.convergenceReserveUsd = 0;
+		this.emitUpdate();
+	}
+	/**
+	* Registers the repair round's MECHANICAL leg (RV3802), the money
+	* twin of the RV3602 per-invocation pool: the round's finish
+	* contract can grant one bounded mechanical repair turn, and the
+	* third comparison run's round entered exactly that turn's price
+	* short of certainty (the repair existed by pool and by contract,
+	* but nothing guaranteed the money would still be there when the
+	* candidate materialized). Held beside the verdict leg from the
+	* moment the round is admitted; released EARLY, to the round's own
+	* finish loop, at its first journaled verdict (a 'repair' verdict is
+	* about to spend the freed money on the granted turn, an 'accepted'
+	* one never needed it), where the verdict leg lives until the judge
+	* dispatch. Exactly the convergence reserve mechanics otherwise:
+	* joins the projected admission sum and both remainders, named in
+	* the refusal clause, never joined to the severing check, idempotent
+	* per account with the root adjusted by the delta.
+	*/
+	commitRepairReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the repair reserve`);
+		const previous = account.repairReserveUsd;
+		account.repairReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.repairReserveUsd = Math.max(0, this.root.repairReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The round's finish loop consumes its leg; see commitRepairReserve. */
+	releaseRepairReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.repairReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.repairReserveUsd = Math.max(0, this.root.repairReserveUsd - account.repairReserveUsd);
+		account.repairReserveUsd = 0;
+		this.emitUpdate();
+	}
 	/** The reserve is replaced by real spend when the spawn settles. */
 	releaseReserve(reserveUsd, accountScope = "run") {
 		for (const account of this.chainOf(accountScope)) account.committedReserveUsd = Math.max(0, account.committedReserveUsd - reserveUsd);
@@ -15426,7 +15548,7 @@ var RunBudget = class {
 		let remaining;
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd;
+			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd - account.convergenceReserveUsd - account.repairReserveUsd;
 			remaining = remaining === void 0 ? headroom : Math.min(remaining, headroom);
 		}
 		return remaining === void 0 ? void 0 : Math.max(0, remaining);
@@ -15669,6 +15791,27 @@ function foldBuckets(source) {
 	return folded;
 }
 /**
+* The scope key rule of the byScope rollup (RV3805). The root's OWN
+* scope is the empty string BY CONSTRUCTION: present data whose string
+* happens to be empty, not an absence, so it folds under the
+* addressable name 'root' instead of the RV3604 'unknown' fallback,
+* which stays reserved for a scope that is truly missing. Children
+* keep their scope strings verbatim. One rule for both builders, so
+* the live report and the journal fold cannot disagree on the key.
+*/
+function scopeBucket(scope) {
+	return scope === void 0 ? "unknown" : scope === "" ? "root" : scope;
+}
+/** {@link scopeBucket} over a whole live map, merging folded keys. */
+function foldScopeBuckets(source) {
+	const folded = {};
+	for (const [key, usd] of source) {
+		const bucket = scopeBucket(key);
+		folded[bucket] = (folded[bucket] ?? 0) + usd;
+	}
+	return folded;
+}
+/**
 * Folds the per-run attribution buckets into the normative CostReport.
 * Live attribution buckets never see abandoned subtrees, so a host
 * that tracked abandoned spend itself passes it as `abandoned`;
@@ -15699,6 +15842,7 @@ function buildCostReport(attribution, totalUsd, abandoned = {
 		byPhase: foldBuckets(attribution.byPhase),
 		byAgentType: foldBuckets(attribution.byAgentType),
 		byRole,
+		byScope: foldScopeBuckets(attribution.byScope),
 		orchestrator: {
 			...orchestrator,
 			share: orchestrator.spentUsd / Math.max(totalUsd, .01)
@@ -15724,6 +15868,7 @@ function costReportFromJournal(entries, priceUsd) {
 	const byModel = {};
 	const byPhase = {};
 	const byAgentType = {};
+	const byScope = {};
 	const byRole = emptyByRole();
 	const unpriced = [];
 	let totalUsd = 0;
@@ -15766,6 +15911,8 @@ function costReportFromJournal(entries, priceUsd) {
 		byPhase[phase] = (byPhase[phase] ?? 0) + priced.usd;
 		const agentType = attributionBucket(facts?.agentType);
 		byAgentType[agentType] = (byAgentType[agentType] ?? 0) + priced.usd;
+		const scope = scopeBucket(entry.scope);
+		byScope[scope] = (byScope[scope] ?? 0) + priced.usd;
 		const primaryRole = facts?.role ?? "loop";
 		for (const unit of priced.units) byRole[unit.role ?? primaryRole] += unit.usd;
 		if (facts?.budgetAccount !== void 0 && isOrchestratorAccount(facts.budgetAccount)) {
@@ -15787,6 +15934,7 @@ function costReportFromJournal(entries, priceUsd) {
 		byPhase,
 		byAgentType,
 		byRole,
+		byScope,
 		orchestrator: {
 			spentUsd: orchestratorSpentUsd,
 			share: orchestratorSpentUsd / Math.max(totalUsd, .01),
@@ -16865,6 +17013,33 @@ function persistedTerminalEnvelope(input) {
 //#endregion
 //#region src/engine/pricing-snapshot.ts
 /**
+* The applied-pricing snapshot (RV407, the eighth-experiment review).
+* `invoiceFromJournal` and `costReportFromJournal` price at fold time
+* from the table the caller passes, so a live price-table update used
+* to silently re-price HISTORY: the same journal folded to different
+* invoices before and after the change. When `createEngine({ pricing })`
+* is configured, the settling segment now pins what it actually
+* applied: the resolved pricing row of every model the journal used
+* (table rows plus the caps-fallback rows of models the table misses),
+* and the table's version, additively inside the existing run-settle
+* decision value (the `outputHash` precedent; no journal shape change).
+* The gate is deliberate: caps-fallback pricing arrives ambiently from
+* adapters, and a setting the user never enabled must not change the
+* journal, so table-less runs settle byte for byte as before.
+* `journalPricingSnapshot` reads the pin back and
+* rebuilds a `priceUsd` from the pinned rows, so a repeated fold after
+* the live table changed reproduces the original numbers exactly.
+*
+* The snapshot governs REPORTING folds (the CLI invoice and inspect
+* cost views, and any host that opts in by passing the rebuilt
+* priceUsd; since RV611 those consumers pass `composedPriceUsd`, the
+* same pin-plus-current-table composition the engine's outcome mirror
+* applies, so a stored fold and the settled outcome can never
+* disagree). The engine's own live pricing, budget admission, and the
+* journaled spend debits are untouched: they were always priced at
+* write time and never re-priced by a fold.
+*/
+/**
 * A pinnable row: every present rate is a finite non-negative number.
 * The fold already treats a broken rate as unpriced (a NaN or negative
 * price never poisons the CostReport), so the pin mirrors exactly that
@@ -16902,6 +17077,42 @@ function snapshotJournalPricing(entries, pricingOf) {
 	}
 	return rows.length === 0 ? void 0 : rows;
 }
+/**
+* The pin's content hash (RV3703): sha256 over the canonical JSON of
+* the rows, so the derivation is byte-stable across folds, engines and
+* platforms; JCS fixes the key order, and the row order is the pin's
+* own (sorted at write, preserved at read).
+*/
+function rowsHashOf(rows) {
+	return createHash("sha256").update(jcsSerialize(rows), "utf8").digest("hex");
+}
+/**
+* The freshness range of a pin's dated rows (RV3703): oldest and
+* newest parsable `ratesVerifiedAt`, original strings preserved.
+* Undefined when no row carries a parsable date.
+*/
+function ratesVerifiedRangeOf(rows) {
+	let oldest;
+	let newest;
+	for (const row of rows) {
+		const raw = row.rates.ratesVerifiedAt;
+		if (raw === void 0) continue;
+		const at = Date.parse(raw);
+		if (!Number.isFinite(at)) continue;
+		if (oldest === void 0 || at < oldest.at) oldest = {
+			at,
+			raw
+		};
+		if (newest === void 0 || at > newest.at) newest = {
+			at,
+			raw
+		};
+	}
+	return oldest === void 0 || newest === void 0 ? void 0 : {
+		oldest: oldest.raw,
+		newest: newest.raw
+	};
+}
 function pinnedRows(value) {
 	const candidate = value?.pricing;
 	if (!Array.isArray(candidate) || candidate.length === 0) return;
@@ -16953,16 +17164,24 @@ function journalPricingSnapshot(entries) {
 		const rates = ratesFor(servedBy, seq);
 		return rates === void 0 ? void 0 : priceUsdOf(rates, usage);
 	};
+	const lastRange = ratesVerifiedRangeOf(last.rows);
 	return {
 		...last.pricingVersion === void 0 ? {} : { pricingVersion: last.pricingVersion },
 		rows: last.rows,
+		rowsHash: rowsHashOf(last.rows),
+		...lastRange === void 0 ? {} : { ratesVerifiedAt: lastRange },
 		pinnedThroughSeq,
-		segments: pins.map((pin, index) => ({
-			fromSeq: index === 0 ? 0 : pins[index - 1]?.seq ?? 0,
-			settleSeq: pin.seq,
-			...pin.pricingVersion === void 0 ? {} : { pricingVersion: pin.pricingVersion },
-			rows: pin.rows
-		})),
+		segments: pins.map((pin, index) => {
+			const range = ratesVerifiedRangeOf(pin.rows);
+			return {
+				fromSeq: index === 0 ? 0 : pins[index - 1]?.seq ?? 0,
+				settleSeq: pin.seq,
+				...pin.pricingVersion === void 0 ? {} : { pricingVersion: pin.pricingVersion },
+				rows: pin.rows,
+				rowsHash: rowsHashOf(pin.rows),
+				...range === void 0 ? {} : { ratesVerifiedAt: range }
+			};
+		}),
 		priceUsd,
 		composedPriceUsd: (current) => (servedBy, usage, seq) => seq !== void 0 && seq < pinnedThroughSeq ? priceUsd(servedBy, usage, seq) ?? current(servedBy, usage) : current(servedBy, usage)
 	};
@@ -18810,6 +19029,7 @@ function createCtx(internals, rootWorkflow) {
 				costBasis: replayBasis,
 				entryRef: terminal?.seq ?? matched.running.seq,
 				...terminal?.usageApprox === true ? { usageApprox: true } : {},
+				...terminal?.hostRejected === true ? { hostRejected: true } : {},
 				...result.exploration === void 0 ? {} : { exploration: result.exploration },
 				...result.toolBudget === void 0 ? {} : { toolBudget: result.toolBudget }
 			}, spanId, true);
@@ -18820,6 +19040,7 @@ function createCtx(internals, rootWorkflow) {
 			});
 			bump(internals.cost.byPhase, state.phase ?? "", costUsd);
 			bump(internals.cost.byAgentType, agentType, costUsd);
+			bump(internals.cost.byScope, state.scope, costUsd);
 			internals.cost.byRole.set(primaryRole, (internals.cost.byRole.get(primaryRole) ?? 0) + costUsd);
 			if (result.status === "escalated" && result.escalation !== void 0) {
 				if (internals.replayer.snapshot().find((entry) => entry.kind === "decision" && entry.value?.targetRef === matched.running.seq) === void 0 && opts.result !== "full" && internals.onEscalation !== void 0) {
@@ -19538,6 +19759,8 @@ function createCtx(internals, rootWorkflow) {
 				}
 			};
 		}
+		const settleSignal = state.signal ?? internals.runSignal;
+		if (result.status !== "ok" && settleSignal?.aborted === true && settleSignal.reason === "rulvar:finish-validation") terminalPatch.hostRejected = true;
 		if (checkpointWritten) terminalPatch.checkpointRef = ckptRef;
 		const terminal = await internals.replayer.appendTerminal(running.seq, terminalPatch);
 		internals.events.emit({
@@ -19551,6 +19774,7 @@ function createCtx(internals, rootWorkflow) {
 			entryRef: terminal.seq,
 			...resultUsageApprox ? { usageApprox: true } : {},
 			...result.transportRetries !== void 0 && result.transportRetries > 0 ? { retryCount: result.transportRetries } : {},
+			...terminalPatch.hostRejected === true ? { hostRejected: true } : {},
 			...result.quotaDenials === void 0 ? {} : { quotaDenials: result.quotaDenials },
 			...result.exploration === void 0 ? {} : { exploration: result.exploration },
 			...result.toolBudget === void 0 ? {} : { toolBudget: result.toolBudget }
@@ -19592,6 +19816,7 @@ function createCtx(internals, rootWorkflow) {
 		}
 		bump(internals.cost.byPhase, state.phase ?? "", usd);
 		bump(internals.cost.byAgentType, agentType, usd);
+		bump(internals.cost.byScope, state.scope, usd);
 		if (result.error?.kind === "budget" || internals.budget.exhausted && result.status !== "ok") {
 			if (!internals.budget.exhausted && result.errorMessage !== void 0 && result.errorMessage.startsWith("in flight exposure cap reached")) throw new BudgetExhaustedError(result.errorMessage, { data: {
 				scope: state.scope,
@@ -21030,6 +21255,50 @@ const MAX_LISTED_CITATIONS = 20;
 const MAX_NAMED_OFFENDING_SENTENCES = 5;
 const MAX_OFFENDING_SENTENCE_CHARS = 240;
 /**
+* The most offending sentences a verdict will hint (RV3801). A
+* document broken in more places than this needs a model repair
+* anyway, and an unbounded hint set would carry unbounded sentence
+* bytes through the live verdict.
+*/
+const MAX_REPAIR_HINTS = 20;
+/**
+* The deterministic edit behind the `insert-run-id` mechanism
+* (RV3801): the id lands INSIDE the sentence, before its trailing
+* terminator run (a `.`, `!`, or `?` with any closing quotes,
+* brackets, or markdown emphasis after it), or at the very end when
+* the sentence carries no terminator. Inside matters: appended AFTER
+* the terminator the id would belong to the NEXT sentence under the
+* shared `sentencesOf` segmentation and the re-validation would fail
+* the same sentence again. Exported so tests and hosts can reproduce
+* the loop's exact bytes.
+*/
+function insertRunIdIntoSentence(sentence, insert) {
+	const at = /[.!?]['")\]*_`]*\s*$/u.exec(sentence)?.index ?? sentence.length;
+	return `${sentence.slice(0, at)} (run ${insert})${sentence.slice(at)}`;
+}
+/**
+* Applies `insert-run-id` repair hints to a judged text (RV3801): each
+* `[start, end)` window is replaced by
+* {@link insertRunIdIntoSentence}(window, insert), right to left so
+* earlier offsets stay valid, every other byte identical. Fail closed:
+* `undefined` (never a partial patch) when the set is empty, any
+* window is out of bounds or empty, or two windows overlap; the caller
+* treats a refused patch exactly like an absent one and proceeds to
+* the model repair pool.
+*/
+function applyFinishRepairHints(text, hints) {
+	if (hints.length === 0) return;
+	const ordered = [...hints].sort((a, b) => a.start - b.start);
+	let previousEnd = 0;
+	for (const hint of ordered) {
+		if (!Number.isInteger(hint.start) || !Number.isInteger(hint.end) || hint.start < previousEnd || hint.end <= hint.start || hint.end > text.length) return;
+		previousEnd = hint.end;
+	}
+	let patched = text;
+	for (const hint of [...ordered].reverse()) patched = patched.slice(0, hint.start) + insertRunIdIntoSentence(patched.slice(hint.start, hint.end), hint.insert) + patched.slice(hint.end);
+	return patched;
+}
+/**
 * The shortest run id {@link evidenceGradeValidator} will accept as an
 * artifact (RV2501). The floor mirrors the id half of
 * {@link DEFAULT_ARTIFACT_PATTERN}: a two character id would satisfy
@@ -21341,6 +21610,13 @@ const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\\w./-]+\
 * the repair instruction is executable rather than aspirational. An id
 * shorter than `MIN_RUN_ID_ARTIFACT_CHARS` (six) is ignored, and
 * without an id the verdict is byte identical to the historical one.
+*
+* With the id in hand the failure also carries {@link FinishRepairHint}
+* rows (RV3801), one per offending sentence, so the finish loop can
+* perform the verdict's own prescription host side without spending a
+* provider wire; the reasons stay byte identical either way, and the
+* hints are bounded (at most `MAX_REPAIR_HINTS` offenders) and fail
+* closed (an id whose bytes could split a sentence is never hinted).
 * Default name 'evidence-grade'.
 */
 function evidenceGradeValidator(options) {
@@ -21360,18 +21636,32 @@ function evidenceGradeValidator(options) {
 			const unsupported = [];
 			const offenders = [];
 			const runId = typeof input.runId === "string" && input.runId.trim().length >= MIN_RUN_ID_ARTIFACT_CHARS ? input.runId.trim() : void 0;
+			let cursor = 0;
 			for (const sentence of sentencesOf(input.text)) {
+				const start = input.text.indexOf(sentence, cursor);
+				cursor = start + sentence.length;
 				const haystack = sentence.toLowerCase();
 				const found = lowered.filter((phrase) => haystack.includes(phrase));
 				if (found.length === 0 || new RegExp(artifactPattern, "").test(sentence) || runId !== void 0 && containsIdentifier(sentence, runId)) continue;
-				offenders.push(sentence);
+				offenders.push({
+					sentence,
+					start,
+					end: start + sentence.length
+				});
 				for (const phrase of found) if (!unsupported.includes(phrase)) unsupported.push(phrase);
 			}
 			if (unsupported.length === 0) return ok;
-			const named = offenders.slice(0, MAX_NAMED_OFFENDING_SENTENCES).map((sentence) => {
+			const named = offenders.slice(0, MAX_NAMED_OFFENDING_SENTENCES).map(({ sentence }) => {
 				const flat = sentence.replace(/\s+/gu, " ").trim();
 				return `offending sentence: "${flat.length <= MAX_OFFENDING_SENTENCE_CHARS ? flat : `${flat.slice(0, MAX_OFFENDING_SENTENCE_CHARS)}...`}"`;
 			});
+			const hints = runId !== void 0 && offenders.length <= MAX_REPAIR_HINTS && !/[.!?]\s|[\r\n]/u.test(runId) && offenders.every((offender) => offender.start >= 0) ? offenders.map(({ sentence, start, end }) => ({
+				mechanism: "insert-run-id",
+				start,
+				end,
+				sentence,
+				insert: runId
+			})) : void 0;
 			const overflow = offenders.length - named.length;
 			return {
 				ok: false,
@@ -21379,7 +21669,8 @@ function evidenceGradeValidator(options) {
 					runId === void 0 ? `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; give each such claim a file:line citation in its own sentence, or state its run id in a SEPARATE sentence carrying no source citation (a run id written beside a path:line citation is not in the cited window and trades this failure for a cited-value one)` : `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; write this run's id ${runId} inside each such sentence, or give the claim a file:line citation instead (the id may share a sentence with a source citation: cited-value reads a run id as identity, not as a value asserted about the cited line)`,
 					...named,
 					...overflow > 0 ? [`and ${String(overflow)} more offending sentences`] : []
-				]
+				],
+				...hints === void 0 ? {} : { repairHints: hints }
 			};
 		}
 	};
@@ -22627,6 +22918,72 @@ function selfTestFinishValidation(options) {
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 const DEFAULT_FINISH_MAX_REPAIRS = 1;
 /**
+* The most hinted edits one deterministic repair attempt will apply
+* (RV3801): a validator caps its own hints well below this, so the
+* bound only guards against a custom validator flooding the journal
+* with patch rows; past it the candidate goes to the model pool.
+*/
+const MAX_DETERMINISTIC_PATCHES = 64;
+/**
+* Plans the sectional claim repair round (RV3803): which H2 sections
+* of the accepted pre-repair document own the judged findings. The
+* third comparison run's round regenerated the WHOLE 43k character
+* document to consume findings that lived in a handful of sentences,
+* and the tail after fan-in was 80.1 percent of the run's wall. Each
+* finding's `draftExcerpt` (whitespace collapsed by the pairing fold)
+* is located in the document through a collapse-aware scan, and its
+* owning section is the nearest H2 line above it. Fail closed to the
+* FULL regeneration (undefined, the historical round byte for byte)
+* whenever the plan cannot be exact: no excerpts, a document without
+* H2 headings, duplicated markers (the splice grammar needs unique
+* lines), or any excerpt the scan cannot locate.
+*/
+function sectionalRoundPlan(document, excerpts) {
+	if (excerpts.length === 0) return;
+	const markers = [];
+	let offset = 0;
+	for (const line of document.split("\n")) {
+		if (line.trim().startsWith("## ")) markers.push({
+			marker: line.trim(),
+			start: offset
+		});
+		offset += line.length + 1;
+	}
+	if (markers.length === 0 || new Set(markers.map((m) => m.marker)).size !== markers.length) return;
+	const collapsed = [];
+	const rawAt = [];
+	let pendingSpace = false;
+	for (let index = 0; index < document.length; index += 1) {
+		const char = document[index] ?? "";
+		if (/\s/u.test(char)) {
+			pendingSpace = collapsed.length > 0;
+			continue;
+		}
+		if (pendingSpace) {
+			collapsed.push(" ");
+			rawAt.push(index);
+			pendingSpace = false;
+		}
+		collapsed.push(char);
+		rawAt.push(index);
+	}
+	const haystack = collapsed.join("");
+	const targets = [];
+	for (const excerpt of excerpts) {
+		const at = haystack.indexOf(excerpt.trim());
+		if (at < 0) return;
+		const raw = rawAt[at] ?? -1;
+		const owner = [...markers].reverse().find((m) => m.start <= raw);
+		if (owner === void 0) return;
+		if (!targets.includes(owner.marker)) targets.push(owner.marker);
+	}
+	targets.sort((a, b) => markers.findIndex((m) => m.marker === a) - markers.findIndex((m) => m.marker === b));
+	return {
+		sections: markers.map((m) => m.marker),
+		targets
+	};
+}
+/**
 * Character cap of the HOST VALIDATION LESSONS prompt block (RV3603):
 * the bounded repair round's prompt folds the run's journaled finish
 * validation failures so the round does not relearn a lesson the run
@@ -22759,6 +23116,8 @@ function validateOrchestrateOptions(opts) {
 		}
 		if (fv.maxRepairs !== void 0) requireNonNegativeInteger(fv.maxRepairs, "orchestrate finishValidation.maxRepairs");
 		if (fv.repairTurnReserve !== void 0) requireNonNegativeInteger(fv.repairTurnReserve, "orchestrate finishValidation.repairTurnReserve");
+		const estRepair = fv.estRepairCostUsd;
+		if (estRepair !== void 0 && (typeof estRepair !== "number" || !Number.isFinite(estRepair) || estRepair < 0)) throw new ConfigError(`orchestrate finishValidation.estRepairCostUsd must be a nonnegative finite number; got ${JSON.stringify(estRepair)}`);
 		const retain = fv.retainRejectedCandidates;
 		if (retain !== void 0 && typeof retain !== "boolean") throw new ConfigError("orchestrate finishValidation.retainRejectedCandidates must be a boolean");
 		const draftPolicy = fv.draftPolicy;
@@ -24127,6 +24486,31 @@ function makeOrchestratorWorkflow(goal, opts) {
 		*/
 		let validationInvocationStart = 0;
 		/**
+		* The staged release of the round's mechanical money leg (RV3802),
+		* armed by the bounded claim repair round right before its
+		* composition dispatches and fired at the round invocation's FIRST
+		* journaled finish verdict: a 'repair' verdict is about to spend
+		* the freed money on the granted turn, an 'accepted' one never
+		* needed it, and a 'rejected' one dies into the round's own
+		* finally, which releases whatever is still armed. Live-only state
+		* on the RV808b doctrine: the hold itself is re-committed by the
+		* re-executed round code on a resume, and full replay never runs
+		* validateFinish at all.
+		*/
+		let releaseRepairLeg;
+		/**
+		* The sectional round context (RV3803), armed by the bounded claim
+		* repair round exactly when {@link sectionalRoundPlan} is exact
+		* over the accepted pre-repair document and the judged findings:
+		* the retained base, its full H2 marker roster, and the target
+		* sections owning the findings. Live state cleared in the round's
+		* finally; a resume re-derives it from replayed material (the
+		* judged findings and the accepted document both replay verbatim),
+		* so the round's prompt bytes stay identical without journaling
+		* anything new.
+		*/
+		let sectionalRoundContext;
+		/**
 		* The contract generation membership test (cycle 73). Without a
 		* contract there are no generations and every decision is current
 		* (the pre 1.77 behavior, byte identical). With one, a decision
@@ -24159,8 +24543,9 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const rows = [];
 			const seen = /* @__PURE__ */ new Set();
 			for (const decision of validationDecisions()) {
-				if (decision.failed.length === 0 || !contractGenerationCurrent(decision)) continue;
-				for (const failure of decision.failed) {
+				const taught = [...decision.failed, ...decision.deterministicRepair?.healed ?? []];
+				if (taught.length === 0 || !contractGenerationCurrent(decision)) continue;
+				for (const failure of taught) {
 					const key = JSON.stringify([failure.name, failure.reasons]);
 					if (seen.has(key)) continue;
 					seen.add(key);
@@ -24299,7 +24684,45 @@ function makeOrchestratorWorkflow(goal, opts) {
 			if (validationSpec === void 0) return { ok: true };
 			let effective = call.result ?? null;
 			let spliced = false;
-			if (finishSectional !== void 0) {
+			if (sectionalRoundContext !== void 0) {
+				const round = sectionalRoundContext;
+				const args = call.args ?? {};
+				const hasSections = Object.hasOwn(args, "sections");
+				const hasResult = Object.hasOwn(args, "result");
+				const guidance = () => ({
+					declaredSections: round.sections,
+					targetSections: round.targets,
+					instruction: "repair ONLY the target sections: call finish({ sections: { \"<marker>\": \"<new section body>\" } }); unchanged sections are spliced from the retained accepted document byte for byte and the spliced whole is validated and judged. Resubmit the full document as result only when a targeted repair is impossible."
+				});
+				if (hasSections && hasResult) return {
+					ok: false,
+					feedback: {
+						error: "pass either result (the full document) or sections (a sectional repair of the retained accepted document), never both",
+						...guidance()
+					}
+				};
+				if (hasSections) {
+					const patch = args.sections;
+					const markers = Object.keys(patch);
+					if (markers.length === 0) return {
+						ok: false,
+						feedback: {
+							error: "sections must name at least one declared section marker",
+							...guidance()
+						}
+					};
+					const unknown = markers.filter((marker) => !round.sections.includes(marker));
+					if (unknown.length > 0) return {
+						ok: false,
+						feedback: {
+							error: `sections names an undeclared section ${unknown.map((marker) => `'${marker}'`).join(", ")}; only the retained document's own markers splice`,
+							...guidance()
+						}
+					};
+					effective = spliceSections(round.base, round.sections, patch);
+					spliced = true;
+				}
+			} else if (finishSectional !== void 0) {
 				const resolution = finishSectional.resolve(call);
 				if (resolution.kind === "refused") return {
 					ok: false,
@@ -24310,6 +24733,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			}
 			const maxRepairs = validationSpec.maxRepairs ?? 1;
 			const known = validationDecisions();
+			let patchedResult;
 			let decision = known.find((candidate) => candidate.callId === call.id);
 			if (decision === void 0) {
 				const result = effective;
@@ -24320,25 +24744,79 @@ function makeOrchestratorWorkflow(goal, opts) {
 					runId: internals.runId
 				};
 				const failed = [];
+				const failureHints = [];
 				for (const validator of validationSpec.validators) {
 					let verdict;
 					try {
 						verdict = validator.validate(input);
 					} catch (thrown) {
 						validationTermination = new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict: ` + (thrown instanceof Error ? thrown.message : String(thrown)));
-						validationAbort.abort("rulvar:finish-validation");
+						validationAbort.abort("rulvar:finish-validation-defect");
 						return {
 							ok: false,
 							feedback: { error: `finish validator '${validator.name}' is defective; the run fails` }
 						};
 					}
-					if (!verdict.ok) failed.push({
-						name: validator.name,
-						reasons: verdict.reasons
-					});
+					if (!verdict.ok) {
+						failed.push({
+							name: validator.name,
+							reasons: verdict.reasons
+						});
+						failureHints.push(verdict.repairHints);
+					}
+				}
+				let deterministicRepair;
+				if (failed.length > 0 && typeof result === "string" && failureHints.every((hints) => hints !== void 0 && hints.length > 0)) {
+					const merged = [];
+					const seenHints = /* @__PURE__ */ new Set();
+					for (const hints of failureHints) for (const hint of hints ?? []) {
+						const key = `${String(hint.start)}:${String(hint.end)}:${hint.insert}`;
+						if (!seenHints.has(key)) {
+							seenHints.add(key);
+							merged.push(hint);
+						}
+					}
+					const patched = merged.length <= MAX_DETERMINISTIC_PATCHES && merged.every((hint) => hint.mechanism === "insert-run-id" && result.slice(hint.start, hint.end) === hint.sentence) ? applyFinishRepairHints(result, merged) : void 0;
+					if (patched !== void 0) {
+						const patchedInput = {
+							result: patched,
+							text: patched,
+							children: input.children,
+							runId: internals.runId
+						};
+						const residual = [];
+						for (const validator of validationSpec.validators) {
+							let verdict;
+							try {
+								verdict = validator.validate(patchedInput);
+							} catch (thrown) {
+								validationTermination = new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict: ` + (thrown instanceof Error ? thrown.message : String(thrown)));
+								validationAbort.abort("rulvar:finish-validation-defect");
+								return {
+									ok: false,
+									feedback: { error: `finish validator '${validator.name}' is defective; the run fails` }
+								};
+							}
+							if (!verdict.ok) residual.push(validator.name);
+						}
+						const patchSurvived = residual.length === 0;
+						deterministicRepair = {
+							mechanism: "insert-run-id",
+							patches: merged.map(({ start, end, insert }) => ({
+								start,
+								end,
+								insert
+							})),
+							beforeHash: createHash("sha256").update(jcsSerialize(result), "utf8").digest("hex"),
+							afterHash: createHash("sha256").update(jcsSerialize(patched), "utf8").digest("hex"),
+							outcome: patchSurvived ? "accepted" : "failed",
+							...patchSurvived ? { healed: failed } : { residual }
+						};
+						if (patchSurvived) patchedResult = patched;
+					}
 				}
 				const repairsUsed = known.filter((candidate, index) => index >= validationInvocationStart && candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
-				const rejectedCandidate = failed.length > 0;
+				const rejectedCandidate = failed.length > 0 && deterministicRepair?.outcome !== "accepted";
 				let candidateRef;
 				if (rejectedCandidate && validationSpec.retainRejectedCandidates === true) {
 					const ref = `${internals.runId}/finish-rejected/${call.id}`;
@@ -24360,10 +24838,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 				decision = {
 					decisionType: "orchestrator_finish_validation",
 					callId: call.id,
-					verdict: failed.length === 0 ? "accepted" : repairsUsed < maxRepairs ? "repair" : "rejected",
-					failed,
+					verdict: failed.length === 0 || deterministicRepair?.outcome === "accepted" ? "accepted" : repairsUsed < maxRepairs ? "repair" : "rejected",
+					failed: deterministicRepair?.outcome === "accepted" ? [] : failed,
 					repairsUsed,
 					maxRepairs,
+					...deterministicRepair === void 0 ? {} : { deterministicRepair },
 					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash },
 					...rejectedCandidate ? {
 						candidateHash: createHash("sha256").update(jcsSerialize(result), "utf8").digest("hex"),
@@ -24380,16 +24859,23 @@ function makeOrchestratorWorkflow(goal, opts) {
 					site: "orchestrator-finish-validation",
 					value: decision
 				});
+				releaseRepairLeg?.();
+			}
+			if (decision.verdict === "accepted") {
+				if (patchedResult !== void 0) return {
+					ok: true,
+					resolved: { result: patchedResult }
+				};
+				return spliced ? {
+					ok: true,
+					resolved: { result: effective }
+				} : { ok: true };
 			}
-			if (decision.verdict === "accepted") return spliced ? {
-				ok: true,
-				resolved: { result: effective }
-			} : { ok: true };
 			finishSectional?.retain(effective);
 			if (decision.verdict === "rejected") {
 				if (contractGenerationCurrent(decision)) {
 					validationTermination = finishValidationError(decision);
-					validationAbort.abort("rulvar:finish-validation");
+					validationAbort.abort(FINISH_REJECTION_ABORT_REASON);
 				}
 				return {
 					ok: false,
@@ -24405,7 +24891,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 					error: "the finish result failed host validation; repair the result and call finish again",
 					failed: decision.failed,
 					repairsRemaining: decision.maxRepairs - decision.repairsUsed - 1,
-					...finishSectional === void 0 ? {} : { sectionalRepair: finishSectional.guidance() }
+					...sectionalRoundContext !== void 0 ? { sectionalRepair: {
+						declaredSections: sectionalRoundContext.sections,
+						targetSections: sectionalRoundContext.targets,
+						instruction: "repair ONLY the target sections: call finish({ sections: { \"<marker>\": \"<new section body>\" } }); unchanged sections are spliced from the retained accepted document byte for byte and the spliced whole is validated and judged. Resubmit the full document as result only when a targeted repair is impossible."
+					} } : finishSectional === void 0 ? {} : { sectionalRepair: finishSectional.guidance() }
 				}
 			};
 		};
@@ -24924,6 +25414,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 		* not settle ok, because an empty list would claim the pool agreed.
 		*/
 		let claimFindingsFound;
+		/**
+		* The observed price of this run's own latest post draft claim
+		* judge pass (RV3701): the fallback sizing of the repair round's
+		* convergence hold when the host declared no `judge.estCost`. By
+		* the time the bounded round can dispatch, a post draft pass has
+		* always settled (the round's findings came from it), so the
+		* fallback is this run's own money, never an invented constant.
+		*/
+		let observedFinalJudgeCostUsd;
 		/** Set whenever the pass ran, findings or not (the RV1404 pairing). */
 		let claimConsistencyMeta;
 		/**
@@ -25208,6 +25707,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			try {
 				judged = await runtime.runInScope(judgeState, () => ctx.agent(judgePrompt, judgeOpts));
 				noteInternalSettle(judged);
+				if (stage !== "draft" && typeof judged.costUsd === "number") observedFinalJudgeCostUsd = judged.costUsd;
 			} catch (declined) {
 				if (!(declined instanceof BudgetExhaustedError)) throw declined;
 				claimConsistencyMeta = finishMeta({
@@ -25462,7 +25962,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const synthesisToolNames = /* @__PURE__ */ new Set([FINISH_TOOL_NAME, ...exposeTools ? [GET_CHILD_RESULT_TOOL_NAME, READ_CHILD_ARTIFACT_TOOL_NAME] : []]);
 			const synthesisTools = buildOrchestratorTools(orchestratorRuntime, fullCardText, {
 				childResultTools: exposeTools,
-				sectionalFinish: synthSectionalFinish
+				sectionalFinish: synthSectionalFinish || sectionalRoundContext !== void 0
 			}).filter((tool) => synthesisToolNames.has(tool.name));
 			if (finishSectional !== void 0 && synthSectionalFinish) finishSectional.retain(draft);
 			const settledEntries = [...byOrdinal.values()].filter((record) => record.settled !== void 0).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => [record.handle, record]);
@@ -25540,6 +26040,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...opts?.contradictions?.onFound !== "carry" || contradictionsFound === void 0 || contradictionsFound.length === 0 ? [] : ["CHILD CONTRADICTIONS: the settled children read these cited locations differently; resolve each one EXPLICITLY in the final result (say which reading holds and why it does) instead of silently picking one. " + JSON.stringify(contradictionsFound)],
 				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : ["CLAIM CONTRADICTIONS: the composed draft contradicts the settled child pool at these cited locations; resolve each one EXPLICITLY in the final result (say which reading holds and why) instead of keeping the inverted claim. " + JSON.stringify(claimFindingsFound)],
 				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : hostValidationLessons(),
+				...sectionalRoundContext === void 0 ? [] : [`RETAINED FINAL: ${JSON.stringify(sectionalRoundContext.base)}`, "SECTIONAL ROUND: the accepted document above is RETAINED; repair ONLY the sections owning the contradicted claims by calling finish({ sections: { \"<marker>\": \"<new section body>\" } }). Unchanged sections are spliced from the retained document byte for byte and the spliced whole is validated and judged. Target sections: " + JSON.stringify(sectionalRoundContext.targets) + ". Declared markers: " + JSON.stringify(sectionalRoundContext.sections) + ". Resubmit the full document as result only when a targeted repair is impossible."],
 				...spec.policyFacts === true ? [(() => {
 					const byStatus = {};
 					let extensionsGranted = 0;
@@ -26391,6 +26892,33 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const hashOfDocument = (value) => createHash("sha256").update(jcsSerialize(value ?? null), "utf8").digest("hex");
 				const preRepairHash = hashOfDocument(synthesizedFinal);
 				const carried = claimFindingsFound;
+				const convergenceHoldUsd = opts?.claimConsistency?.judge?.estCost ?? observedFinalJudgeCostUsd ?? 0;
+				const convergenceScope = orchestratorAccount ?? "run";
+				if (convergenceHoldUsd > 0) internals.budget.commitConvergenceReserve(convergenceScope, convergenceHoldUsd);
+				const repairHoldUsd = validationSpec === void 0 ? 0 : validationSpec.estRepairCostUsd ?? lastMechanicalRepairCostUsd(internals.replayer.snapshot(), (servedBy, usage) => internals.priceUsd(servedBy, usage)) ?? 0;
+				if (repairHoldUsd > 0) {
+					internals.budget.commitRepairReserve(convergenceScope, repairHoldUsd);
+					releaseRepairLeg = () => {
+						releaseRepairLeg = void 0;
+						internals.budget.releaseRepairReserve(convergenceScope);
+					};
+				}
+				const roundPlan = validationSpec !== void 0 && typeof synthesizedFinal === "string" ? sectionalRoundPlan(synthesizedFinal, carried.map((finding) => finding.draftExcerpt)) : void 0;
+				if (roundPlan !== void 0) {
+					sectionalRoundContext = {
+						base: synthesizedFinal,
+						...roundPlan
+					};
+					internals.events.emit({
+						type: "log",
+						level: "debug",
+						msg: "orchestrator sectional round armed",
+						data: {
+							targets: roundPlan.targets,
+							sections: roundPlan.sections.length
+						}
+					}, callingState.spanId);
+				}
 				try {
 					synthesizedFinal = await runSynthesis(result.output);
 				} catch (thrown) {
@@ -26422,8 +26950,24 @@ function makeOrchestratorWorkflow(goal, opts) {
 						preRepairHash,
 						...acceptanceSnapshot
 					} });
+				} finally {
+					sectionalRoundContext = void 0;
+					releaseRepairLeg = void 0;
+					if (repairHoldUsd > 0) internals.budget.releaseRepairReserve(convergenceScope);
+					if (convergenceHoldUsd > 0) internals.budget.releaseConvergenceReserve(convergenceScope);
+				}
+				try {
+					await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
+				} catch (thrown) {
+					if (thrown instanceof FailRunError && typeof thrown.data === "object" && thrown.data !== null && !Array.isArray(thrown.data) && thrown.data.source === "orchestrator_claim_consistency") throw new FailRunError(thrown.message, { data: {
+						...thrown.data,
+						...thrown.data.claimContradictions === void 0 ? { claimContradictions: carried } : {},
+						roundDispatched: true,
+						repairsUsed: 1,
+						preRepairHash
+					} });
+					throw thrown;
 				}
-				await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
 				if (claimFindingsFound !== void 0 && claimFindingsFound.length > 0) throw new FailRunError(`the claim-consistency judge still found ${String(claimFindingsFound.length)} contradiction${claimFindingsFound.length === 1 ? "" : "s"} after the bounded repair round: the repaired composition keeps contradicting the settled pool`, { data: {
 					source: "orchestrator_claim_consistency",
 					claimContradictions: claimFindingsFound,
@@ -28613,6 +29157,7 @@ function createEngine(options) {
 				byModel: /* @__PURE__ */ new Map(),
 				byPhase: /* @__PURE__ */ new Map(),
 				byAgentType: /* @__PURE__ */ new Map(),
+				byScope: /* @__PURE__ */ new Map(),
 				byRole: /* @__PURE__ */ new Map(),
 				unpriced: [],
 				orchestrator: {
@@ -29570,4 +30115,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyFinishRepairHints, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, insertRunIdIntoSentence, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastMechanicalRepairCostUsd, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, scopeBucket, sectionCitationsValidator, sectionPatternCountValidator, sectionalRoundPlan, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };