@rulvar/evals 1.242.0 → 1.244.0

package/dist/index.d.ts

@@ -843,9 +843,20 @@ declare function runFaultInjection(options?: RunFaultInjectionOptions): Promise<
 * classes, plus the nineteenth benchmark's pair (RV1809):
 * 'modality-overclaim' is a mitigation stated as an unconditional
 * guarantee, and 'scope-ambiguity' is a child-only total printed as a
-* whole-workflow figure.
+* whole-workflow figure. The third comparison experiment validated
+* three more (RV3804): 'bound-conflation' lists opt-in caps and
+* unconditional guards as one mode, 'derived-premise' is a derived
+* figure whose premise contradicts the declared input (2,000 slots
+* computed from a 30 minute window where the input declares a 20
+* minute burst), and 'cost-basis' prints a locally estimated total as
+* the provider's bill. The fourth comparison experiment named the
+* decisive one (RV3909): 'stale-doctrine-echo' is a draft echoing a
+* DOCUMENTED doctrine while the pool holds the diverging source fact,
+* both sides cited; the experiment's answer echoed the retired
+* budget-immutability wording from a guide six weeks stale, and no
+* judge could flag it because the pool never carried the source side.
 */
-type ClaimCorpusClass = "live-fact" | "package-identity" | "inverted-default" | "numeric-range" | "negation" | "bounded-coverage" | "modality-overclaim" | "scope-ambiguity";
+type ClaimCorpusClass = "live-fact" | "package-identity" | "inverted-default" | "numeric-range" | "negation" | "bounded-coverage" | "modality-overclaim" | "scope-ambiguity" | "bound-conflation" | "derived-premise" | "cost-basis" | "stale-doctrine-echo";
 /** One adversarial case: a draft, its contradicting evidence, and the mechanical expectations. */
 interface ClaimCorpusCase {
   id: string;

package/dist/index.js

@@ -3397,23 +3397,23 @@ const resumeSpawnFamine = {
 * beside the live-observed claim, the model wove the id into a cited
 * sentence, cited-value lawfully rejected the id as a value absent from
 * the cited window, and both repairs burned without an exit. The
-* evidence-grade reason now NAMES the safe composition, so the same
-* trap converges in one repair round with cited-value silent. It also
-* names the id ITSELF (RV2501): the 1.226.0 comparison run obeyed the
-* same reason with an id no artifact pattern could match, so the
-* instruction was unexecutable and both repairs burned again. And the
-* composition it names is now the DIRECT one (RV2502): with the id in
-* hand cited-value reads it as identity rather than as a value asserted
-* about the cited line, so the corrected finish here writes this run's
-* own id in the graded sentence BESIDE the citation, the exact shape
-* the old bundle could not accept from either side.
+* evidence-grade reason then learned to NAME the safe composition
+* (RV2202) and the id itself (RV2501), with cited-value reading that id
+* as identity (RV2502), so the trap converged in one repair round. The
+* deterministic patch (RV3801) closes the arc: the host now PERFORMS
+* the reason's own prescription, so the same trap converges in ZERO
+* model repairs, the third subscription run's two burned wires cost
+* nothing at all, cited-value stays silent over the patched document,
+* and the guidance bytes remain journaled on the healed verdict for
+* the failure shapes a patch cannot reach.
 */
 const validatorGuidanceConflict = {
 	name: "validator-guidance-conflict",
-	doctrine: "the evidence-grade reason names the SAFE composition against its cited-value sibling and names the run id it wants written (RV2202, RV2501, RV2502): the c3 trap finish repairs in ONE round by carrying THIS run's own id in the graded sentence, beside a source citation, with cited-value reading that id as identity and never rejecting; the third subscription run burned both repairs between the two verdicts, and the 1.226.0 comparison run burned both again on an id no artifact pattern could match",
+	doctrine: "the evidence-grade reason names the SAFE composition against its cited-value sibling and names the run id it wants written (RV2202, RV2501, RV2502), and the finish loop now performs that prescription itself (RV3801): the c3 trap heals in ZERO model repairs, the accepted document carries THIS run's own id inside the graded sentence with cited-value reading it as identity and never rejecting, and the composition-safe guidance bytes ride the journaled healed verdict; the third subscription run burned both repairs between the two verdicts, and the 1.226.0 comparison run burned both again on an id no artifact pattern could match",
 	async run() {
 		const TRAP_FINISH = "The reserve fold is live-observed under sustained load. The engine seals the journal at settle (`README.md:3`).";
 		const FIXED_FINISH = "The reserve fold is live-observed under sustained load in run `fault-guidance-conflict`, where the engine seals the journal at settle (`README.md:3`).";
+		const PATCHED_TRAP = "The reserve fold is live-observed under sustained load (run fault-guidance-conflict). The engine seals the journal at settle (`README.md:3`).";
 		const calls = [];
 		let finishAttempts = 0;
 		const adapter = {
@@ -3462,28 +3462,20 @@ const validatorGuidanceConflict = {
 			budgetUsd: 10
 		}).result;
 		const entries = await store.load("fault-guidance-conflict");
-		const repairRequest = calls[1];
-		const repairBytes = JSON.stringify(repairRequest?.messages ?? []);
-		const guidanceQuoted = repairBytes.includes("write this run's id fault-guidance-conflict") && repairBytes.includes("may share a sentence with a source citation");
-		const citedValueNamed = repairBytes.includes("cited-value reads a run id as identity");
-		const decisionsText = JSON.stringify(entries.filter((entry) => entry.kind === "decision").map((entry) => entry.value ?? null));
-		const citedValueRejected = decisionsText.includes("\"cited-value\"") ? decisionsText.includes("not present inside the cited window") : false;
+		const decision = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value)[0];
+		const healedReasons = (decision?.deterministicRepair?.healed ?? []).flatMap((failure) => failure.reasons ?? []).join(" ");
+		const guidanceQuoted = healedReasons.includes("write this run's id fault-guidance-conflict") && healedReasons.includes("may share a sentence with a source citation");
+		const citedValueNamed = healedReasons.includes("cited-value reads a run id as identity");
+		const citedValueRejected = JSON.stringify(entries.filter((entry) => entry.kind === "decision").map((entry) => entry.value ?? null)).includes("not present inside the cited window");
 		return {
 			observation: {
-				matched: outcome.status === "ok" && outcome.value === FIXED_FINISH && finishAttempts === 2 && guidanceQuoted && citedValueNamed && !citedValueRejected,
-				detail: `run '${outcome.status}' after ${String(finishAttempts)} finish attempt(s); the repair exchange named the run id and the shared-sentence composition (${String(guidanceQuoted)}) and named the identity reading (${String(citedValueNamed)}); cited-value rejected=${String(citedValueRejected)}; final result carries this run's own id beside the citation in the graded sentence: ${String(outcome.value === FIXED_FINISH)}`
+				matched: outcome.status === "ok" && outcome.value === PATCHED_TRAP && finishAttempts === 1 && decision?.verdict === "accepted" && decision.deterministicRepair?.outcome === "accepted" && guidanceQuoted && citedValueNamed && !citedValueRejected,
+				detail: `run '${outcome.status}' after ${String(finishAttempts)} finish attempt(s), healed host side (patch outcome='${String(decision?.deterministicRepair?.outcome)}'); the journaled healed verdict named the run id and the shared-sentence composition (${String(guidanceQuoted)}) and named the identity reading (${String(citedValueNamed)}); cited-value rejected=${String(citedValueRejected)}; final result carries this run's own id inside the graded sentence: ` + String(outcome.value === PATCHED_TRAP)
 			},
-			artifacts: [
-				jsonArtifact("outcome.json", {
-					status: outcome.status,
-					value: outcome.value ?? null
-				}),
-				{
-					name: "repair-request.json",
-					content: repairBytes
-				},
-				jsonArtifact("journal.json", entries)
-			]
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null
+			}), jsonArtifact("journal.json", entries)]
 		};
 	}
 };
@@ -3577,6 +3569,514 @@ function tailSpans(entries) {
 		judges: settled.filter((entry) => entry.costAttribution?.label === "claim-consistency-judge-final")
 	};
 }
+/**
+* RV3307 as the arc the losing config wanted: the final judge names
+* the contradiction, the findings ride one more composition, the
+* re-judge clears the repaired document, and the settled envelope
+* reports THAT document as the judged one.
+*/
+const repairRoundHonesty = {
+	name: "repair-round-honesty",
+	doctrine: "the bounded post judge repair consumes the named finding (RV3307): one more composition carries the findings, the re-judge clears it, the run settles ok with the meta describing the repaired document (judgedStage 'final', findings 0, judgedHash equal to the shipped finalHash), two compositions and two final judge passes in the journal, and the invoice in the same denominator as the envelope",
+	async run() {
+		const { engine, store } = tailEngine(tailAdapter({
+			judge: (call) => call === 1 ? TAIL_FINDS : TAIL_AGREES,
+			finals: [TAIL_FINAL_INVERTED, TAIL_FINAL_CLEAN]
+		}));
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			}
+		}), void 0, {
+			runId: "fault-repair-honesty",
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		const entries = await store.load("fault-repair-honesty");
+		const { compositions, judges } = tailSpans(entries);
+		const invoice = invoiceFromJournal(entries, () => 0);
+		return {
+			observation: {
+				matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && Array.isArray(value.claimContradictions) && value.claimContradictions.length === 0 && value.claimConsistencyMeta?.judgedStage === "final" && value.claimConsistencyMeta.findings === 0 && typeof value.claimConsistencyMeta.judgedHash === "string" && value.claimConsistencyMeta.judgedHash === value.draftToFinal?.finalHash && compositions.length === 2 && judges.length === 2 && [...compositions, ...judges].every((entry) => entry.status === "ok") && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests,
+				detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the repaired document" : "an unexpected document"}; meta judgedStage='${String(value?.claimConsistencyMeta?.judgedStage)}' findings=${String(value?.claimConsistencyMeta?.findings)} judgedHash==finalHash=${String(value?.claimConsistencyMeta?.judgedHash === value?.draftToFinal?.finalHash)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es); wires ${String(outcome.envelope.wireRequests)} == invoice ` + String(invoice.cardinality.wireRequests)
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* RV3307's refusal half: the repair round runs, the re-judge still
+* finds, and the run fails typed instead of settling over the
+* surviving contradiction, with the payload distinguishing the two
+* documents by hash.
+*/
+const repairSurvivorRefusal = {
+	name: "repair-survivor-refusal",
+	doctrine: "findings that survive the bounded repair round fail the run typed (RV3307): source 'orchestrator_claim_consistency', repairsUsed 1, preRepairHash distinct from repairedHash (the round demonstrably produced a different document and the judge still refused it), two compositions and two final judge passes paid, never a silent ok over the surviving contradiction",
+	async run() {
+		const { engine, store } = tailEngine(tailAdapter({
+			judge: () => TAIL_FINDS,
+			finals: [TAIL_FINAL_INVERTED, TAIL_FINAL_STILL_INVERTED]
+		}));
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			}
+		}), void 0, {
+			runId: "fault-repair-survivor",
+			budgetUsd: 10
+		}).result;
+		const data = outcome.error?.data ?? {};
+		const entries = await store.load("fault-repair-survivor");
+		const { compositions, judges } = tailSpans(entries);
+		return {
+			observation: {
+				matched: outcome.status === "error" && (outcome.error?.message ?? "").includes("after the bounded repair round") && data.source === "orchestrator_claim_consistency" && data.repairsUsed === 1 && typeof data.preRepairHash === "string" && typeof data.repairedHash === "string" && data.preRepairHash !== data.repairedHash && compositions.length === 2 && judges.length === 2,
+				detail: `run '${outcome.status}': ${outcome.error?.message ?? ""}; repairsUsed=${String(data.repairsUsed)}, hashes distinct=${String(data.preRepairHash !== data.repairedHash)}, ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				error: outcome.error ?? null
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* The round's second death told straight (RV3601): the third
+* comparison run's repair round DISPATCHED, paid two wires, produced
+* a candidate its own finish contract rejected, and the terminal read
+* 'could not dispatch' with repairsUsed 0 beside a null judge meta
+* and null findings. The class now names the host rejection, counts
+* the bounded round as spent, mirrors the finish verdict facts, and
+* the engine lifts the findings beside the meta onto the outcome.
+*/
+const repairRoundHostRejection = {
+	name: "repair-round-host-rejection",
+	doctrine: "a repair round that dispatched and lost its candidate to the finish contract fails typed as a host rejection (RV3601): the message names the dispatch, never 'could not dispatch'; data carries roundDispatched true, repairsUsed 1, the judge meta beside the findings, and the finish verdict verbatim (failed validators, candidateHash, candidateChars); the outcome lifts the findings beside the meta",
+	async run() {
+		const { engine, store } = tailEngine(tailAdapter({
+			judge: () => TAIL_FINDS,
+			finals: [
+				TAIL_FINAL_INVERTED,
+				TAIL_FINAL_UNGROUNDED,
+				TAIL_FINAL_UNGROUNDED
+			]
+		}));
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			},
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1
+			}
+		}), void 0, {
+			runId: "fault-repair-host-rejection",
+			budgetUsd: 10
+		}).result;
+		const data = outcome.error?.data ?? {};
+		const entries = await store.load("fault-repair-host-rejection");
+		const { compositions, judges } = tailSpans(entries);
+		const liftedFindings = outcome.claimContradictions;
+		const message = outcome.error?.message ?? "";
+		return {
+			observation: {
+				matched: outcome.status === "error" && message.includes("dispatched and its repaired candidate failed host validation") && !message.includes("could not dispatch") && data.source === "orchestrator_claim_consistency" && data.roundDispatched === true && data.repairsUsed === 1 && data.claimConsistencyMeta?.findings === 1 && Array.isArray(data.claimContradictions) && data.claimContradictions.length === 1 && typeof data.finishValidation?.callId === "string" && data.finishValidation.repairsUsed === 1 && data.finishValidation.maxRepairs === 1 && typeof data.finishValidation.candidateHash === "string" && typeof data.finishValidation.candidateChars === "number" && JSON.stringify(data.finishValidation.failed ?? null).includes("provenance-anchor") && Array.isArray(liftedFindings) && liftedFindings.length === 1 && compositions.length === 2 && judges.length === 1,
+				detail: `run '${outcome.status}': roundDispatched=${String(data.roundDispatched)}, repairsUsed=${String(data.repairsUsed)}, meta findings=${String(data.claimConsistencyMeta?.findings)}, finish verdict carries hash=${String(typeof data.finishValidation?.candidateHash === "string")} chars=${String(data.finishValidation?.candidateChars)}, outcome lifts findings=${String(Array.isArray(liftedFindings))}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				error: outcome.error ?? null
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* The mechanical repair pool belongs to the invocation (RV3602): the
+* third comparison run's initial composition spent the single run
+* wide repair, so the bounded round entered with zero retries by
+* construction and its first regression was final. This scenario is
+* that exact frozen sequence carried one step further: the initial
+* composition trips the contract and repairs mechanically, the final
+* judge finds the real contradiction, the round's candidate trips the
+* contract AGAIN, and the round's OWN fresh pool grants the retry
+* that lands the clean document; the run settles ok over it.
+*/
+const repairRoundOwnPool = {
+	name: "repair-round-own-pool",
+	doctrine: "the mechanical repair pool belongs to one composition invocation (RV3602): the bounded claim repair round enters with the full maxRepairs even after the initial composition spent its own, so the frozen third comparison sequence converges to ok/complete with verdicts repair/accepted twice and repairsUsed restarting at the invocation boundary, never a host rejection born of an inherited spent pool; the round's prompt also carries the HOST VALIDATION LESSONS block naming the failure the run already paid for (RV3603), while the initial composition carries none",
+	async run() {
+		let judgeCalls = 0;
+		const adapter = tailAdapter({
+			judge: () => (judgeCalls += 1) === 1 ? TAIL_FINDS : TAIL_AGREES,
+			finals: [
+				TAIL_FINAL_UNGROUNDED_INITIAL,
+				TAIL_FINAL_INVERTED,
+				TAIL_FINAL_UNGROUNDED,
+				TAIL_FINAL_CLEAN
+			]
+		});
+		const { engine, store } = tailEngine(adapter);
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			},
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1
+			}
+		}), void 0, {
+			runId: "fault-repair-own-pool",
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		const entries = await store.load("fault-repair-own-pool");
+		const { compositions, judges } = tailSpans(entries);
+		const verdictRows = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value);
+		const verdicts = verdictRows.map((row) => row.verdict).join(",");
+		const pools = verdictRows.map((row) => String(row.repairsUsed)).join(",");
+		const compositionPrompts = adapter.calls.filter((call) => call.label === "final-composition").map((call) => call.prompt);
+		const lessonCarried = compositionPrompts.length === 4 && compositionPrompts[0]?.includes("HOST VALIDATION LESSONS") === false && compositionPrompts[2]?.includes("HOST VALIDATION LESSONS") === true && compositionPrompts[2]?.includes("provenance-anchor") === true;
+		return {
+			observation: {
+				matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && value.claimConsistencyMeta?.findings === 0 && verdicts === "repair,accepted,repair,accepted" && pools === "0,1,0,1" && (value.rejectedFinishCandidates?.length ?? 0) === 2 && value.rejectedFinishCandidates?.every((row) => row.verdict === "repair") === true && lessonCarried && compositions.length === 2 && judges.length === 2,
+				detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the repaired document" : "an unexpected document"}; verdicts [${verdicts}], repairsUsed [${pools}] (fresh pool at the invocation boundary); lesson carried=${String(lessonCarried)}; meta findings=${String(value?.claimConsistencyMeta?.findings)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* The convergence hold (RV3701): the round is a two invocation
+* bargain, and the third comparison run's class was an honest fail
+* closed WITHOUT convergence. RV3602 gave the round its own mechanical
+* pool; this hold closes the money twin: the verdict money is held
+* from the moment the round is admitted, so a round the budget can
+* only start refuses BEFORE any of its wires instead of paying for a
+* candidate nobody can rule on.
+*/
+const repairRoundVerdictReserve = {
+	name: "repair-round-verdict-reserve",
+	doctrine: "the repair round pays for its verdict up front (RV3701): the money of the round second judge pass (the declared judge estCost first, else the run own observed post draft judge price) is held from the moment the round is admitted, a round the budget can only start refuses through the honest pre dispatch class before any of its wires with the held convergence reserve named in the refusal arithmetic, and exactly one composition is ever paid for",
+	async run() {
+		const { engine, store } = tailEngine(tailAdapter({
+			judge: () => TAIL_FINDS,
+			finals: [TAIL_FINAL_INVERTED]
+		}));
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			synthesis: {
+				limits: { maxTurns: 3 },
+				estCost: .2
+			},
+			budget: {
+				capUsd: .3,
+				capFraction: 1
+			},
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair",
+				judge: { estCost: .2 }
+			}
+		}), void 0, {
+			runId: "fault-repair-verdict-reserve",
+			budgetUsd: 10
+		}).result;
+		const data = outcome.error?.data ?? {};
+		const entries = await store.load("fault-repair-verdict-reserve");
+		const { compositions, judges } = tailSpans(entries);
+		const message = outcome.error?.message ?? "";
+		const holdNamed = message.includes("held convergence reserve 0.2000");
+		return {
+			observation: {
+				matched: outcome.status === "error" && message.includes("could not dispatch") && holdNamed && data.source === "orchestrator_claim_consistency" && data.roundDispatched === false && data.repairsUsed === 0 && data.claimConsistencyMeta?.findings === 1 && compositions.length === 1 && judges.length === 1,
+				detail: `run '${outcome.status}': roundDispatched=${String(data.roundDispatched)}, repairsUsed=${String(data.repairsUsed)}, held convergence reserve named=${String(holdNamed)}; ${String(compositions.length)} composition(s) paid, ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				error: outcome.error ?? null
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* The mechanical leg of the convergence hold (RV3802): RV3701 holds
+* the verdict money and RV3602 gives the round its own repair pool,
+* but the one mechanical repair turn that pool can grant was funded by
+* nothing. This drives the ceiling where the round could pay its
+* composition and its verdict but not the granted repair: the refusal
+* fires pre dispatch with BOTH legs named in the printed arithmetic.
+*/
+const repairRoundMechanicalReserve = {
+	name: "repair-round-mechanical-reserve",
+	doctrine: "the repair round pays ahead for its one mechanical repair turn too (RV3802): the declared finishValidation.estRepairCostUsd is held beside the verdict money from the moment the round is admitted, a round that could seat only its composition and verdict refuses through the honest pre dispatch class before any of its wires, with the held convergence reserve AND the held repair reserve both named in the refusal arithmetic, and exactly one composition ever paid for",
+	async run() {
+		const { engine, store } = tailEngine(tailAdapter({
+			judge: () => TAIL_FINDS,
+			finals: [TAIL_FINAL_INVERTED]
+		}));
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			synthesis: {
+				limits: { maxTurns: 3 },
+				estCost: .2
+			},
+			budget: {
+				capUsd: .5,
+				capFraction: 1
+			},
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair",
+				judge: { estCost: .2 }
+			},
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1,
+				estRepairCostUsd: .15
+			}
+		}), void 0, {
+			runId: "fault-repair-mechanical-reserve",
+			budgetUsd: 10
+		}).result;
+		const data = outcome.error?.data ?? {};
+		const entries = await store.load("fault-repair-mechanical-reserve");
+		const { compositions, judges } = tailSpans(entries);
+		const message = outcome.error?.message ?? "";
+		const verdictNamed = message.includes("held convergence reserve 0.2000");
+		const mechanicalNamed = message.includes("held repair reserve 0.1500");
+		return {
+			observation: {
+				matched: outcome.status === "error" && message.includes("could not dispatch") && verdictNamed && mechanicalNamed && data.source === "orchestrator_claim_consistency" && data.roundDispatched === false && data.repairsUsed === 0 && data.claimConsistencyMeta?.findings === 1 && compositions.length === 1 && judges.length === 1,
+				detail: `run '${outcome.status}': roundDispatched=${String(data.roundDispatched)}, repairsUsed=${String(data.repairsUsed)}, held convergence reserve named=${String(verdictNamed)}, held repair reserve named=${String(mechanicalNamed)}; ${String(compositions.length)} composition(s) paid, ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				error: outcome.error ?? null
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+const SECTIONAL_PREFIX = "# Audit\n\n## Fine\n\nThe ledger holds one denominator.\n\n";
+const SECTIONAL_FINAL_INVERTED = `${SECTIONAL_PREFIX}## Verdict\n\nfinal: an audit-write failure does not turn success into failure [src/exec.ts:256-296].
+`;
+const SECTIONAL_VERDICT_BODY = "final: a failed audit write does not mask success [src/exec.ts:256-296].\n";
+const SECTIONAL_SPLICED = `${SECTIONAL_PREFIX}## Verdict\n${SECTIONAL_VERDICT_BODY}`;
+const sectionalRepairRound = {
+	name: "sectional-repair-round",
+	doctrine: "the bounded claim repair round repairs ONLY the sections owning the judged findings (RV3803): the round prompt retains the accepted document and names the target sections, the model resubmits one section body, the host splices it into the retained document with every other byte identical, and the FULL validator set plus the final judge rule on the spliced whole; two compositions, two judge passes, no mechanical repair spent",
+	async run() {
+		let judgeCalls = 0;
+		let synthCalls = 0;
+		let loopTurns = 0;
+		const adapter = new FakeAdapter({ agents: {
+			"claim-consistency-judge-final": () => (judgeCalls += 1) === 1 ? TAIL_FINDS : TAIL_AGREES,
+			"final-composition": () => (synthCalls += 1) === 1 ? fakeToolCalls({
+				name: "finish",
+				args: { result: SECTIONAL_FINAL_INVERTED }
+			}) : fakeToolCalls({
+				name: "finish",
+				args: { sections: { "## Verdict": SECTIONAL_VERDICT_BODY } }
+			}),
+			worker: TAIL_POOL_READING,
+			"*": (call) => {
+				loopTurns += 1;
+				if (loopTurns === 1) return fakeToolCalls({
+					name: "spawn_agent",
+					args: {
+						agentType: "worker",
+						prompt: "read the recorded span"
+					}
+				});
+				if (loopTurns === 2) return fakeToolCalls({
+					name: "await_all",
+					args: { handles: tailHandles(call.req) }
+				});
+				return fakeToolCalls({
+					name: "finish",
+					args: { result: TAIL_DRAFT_INVERTED }
+				});
+			}
+		} });
+		const { engine, store } = tailEngine(adapter);
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			},
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1
+			}
+		}), void 0, {
+			runId: "fault-sectional-round",
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		const entries = await store.load("fault-sectional-round");
+		const { compositions, judges } = tailSpans(entries);
+		const verdictRows = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value);
+		const roundPrompts = adapter.calls.filter((call) => call.label === "final-composition").map((call) => call.prompt);
+		const sectionalPrompt = roundPrompts.length === 2 && roundPrompts[0]?.includes("SECTIONAL ROUND") === false && roundPrompts[1]?.includes("SECTIONAL ROUND") === true && roundPrompts[1]?.includes("\"## Verdict\"") === true && roundPrompts[0]?.includes("retained evidence discipline") === false && roundPrompts[1]?.includes("retained evidence discipline") === true;
+		const byteIdentity = value?.result === SECTIONAL_SPLICED && String(value.result).startsWith(SECTIONAL_PREFIX);
+		const lineage = value?.claimConsistencyMeta?.passes === 2 && value.claimConsistencyMeta.firstPassFindings === 1 && value.claimConsistencyMeta.semanticRepairRounds === 1;
+		return {
+			observation: {
+				matched: outcome.status === "ok" && byteIdentity && value.claimConsistencyMeta?.findings === 0 && lineage && verdictRows.map((row) => row.verdict).join(",") === "accepted,accepted" && verdictRows.map((row) => String(row.repairsUsed)).join(",") === "0,0" && sectionalPrompt && compositions.length === 2 && judges.length === 2,
+				detail: `run '${outcome.status}' shipped ${value?.result === SECTIONAL_SPLICED ? "the spliced whole" : "an unexpected document"}; byte identity=${String(byteIdentity)}; sectional prompt=${String(sectionalPrompt)}; lineage=${String(lineage)}; verdicts [${verdictRows.map((row) => row.verdict).join(",")}]; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+const sectionalRepairRoundFallback = {
+	name: "sectional-repair-round-fallback",
+	doctrine: "a round whose plan cannot be exact regenerates in full, byte for byte the historical round (RV3803): a document without H2 headings arms no sectional context, the round prompt carries neither the retained document nor a target list, and the full regeneration converges exactly as before",
+	async run() {
+		let judgeCalls = 0;
+		const adapter = tailAdapter({
+			judge: () => (judgeCalls += 1) === 1 ? TAIL_FINDS : TAIL_AGREES,
+			finals: [TAIL_FINAL_INVERTED, TAIL_FINAL_CLEAN]
+		});
+		const { engine, store } = tailEngine(adapter);
+		const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				onFound: "repair"
+			},
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1
+			}
+		}), void 0, {
+			runId: "fault-sectional-fallback",
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		const entries = await store.load("fault-sectional-fallback");
+		const { compositions, judges } = tailSpans(entries);
+		const roundPrompts = adapter.calls.filter((call) => call.label === "final-composition").map((call) => call.prompt);
+		const fullRegeneration = roundPrompts.length === 2 && roundPrompts[1]?.includes("CLAIM CONTRADICTIONS") === true && roundPrompts[1]?.includes("SECTIONAL ROUND") === false && roundPrompts[1]?.includes("RETAINED FINAL") === false;
+		return {
+			observation: {
+				matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && fullRegeneration && compositions.length === 2 && judges.length === 2,
+				detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the regenerated document" : "an unexpected document"}; full regeneration=${String(fullRegeneration)} (sectional block absent); ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* The armed posture doctrine on a dead judge (RV3307): a gate armed to
+* stop or to repair must not pass silently when its judge cannot rule.
+* Both armed postures refuse typed; the round never runs.
+*/
+const claimJudgeDeadArmedRefusal = {
+	name: "claim-judge-dead-armed-refusal",
+	doctrine: "a final stage judge that dies on the wire under an armed posture fails the run typed for both 'fail' and 'repair' (RV3307), each message naming its armed posture, with exactly one composition paid and no repair round dispatched, never a silent settle over findings nobody ruled on",
+	async run() {
+		const judgeDeath = () => fakeWireError({
+			code: "agent",
+			message: "the judge died mid stream",
+			retryable: false,
+			data: {}
+		});
+		const runs = [];
+		const journals = {};
+		for (const posture of ["fail", "repair"]) {
+			const { engine, store } = tailEngine(tailAdapter({
+				judge: judgeDeath,
+				finals: [TAIL_FINAL_INVERTED]
+			}));
+			const runId = `fault-dead-judge-${posture}`;
+			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+				...TAIL_OPTS,
+				claimConsistency: {
+					stage: "final",
+					onFound: posture
+				}
+			}), void 0, {
+				runId,
+				budgetUsd: 10
+			}).result;
+			const entries = await store.load(runId);
+			const { compositions, judges } = tailSpans(entries);
+			journals[posture] = entries;
+			runs.push({
+				posture,
+				status: outcome.status,
+				message: outcome.error?.message ?? "",
+				compositions: compositions.length,
+				judges: judges.length
+			});
+		}
+		return {
+			observation: {
+				matched: runs.every((run) => run.status === "error" && run.message.includes(`armed ${run.posture} posture`) && run.compositions === 1 && run.judges === 1),
+				detail: runs.map((run) => `${run.posture}: '${run.status}' (${run.compositions} composition(s), ${run.judges} judge span(s)) ${run.message.slice(0, 120)}`).join(" | ")
+			},
+			artifacts: [jsonArtifact("runs.json", runs), jsonArtifact("journals.json", journals)]
+		};
+	}
+};
+/**
+* The deterministic provenance patch (RV3801): the third comparison
+* run died twice on a failure class whose remedy the evidence-grade
+* verdict prescribes word for word (write this run's id inside each
+* offending sentence). The finish loop now performs that prescription
+* host side; this drives the arc on the real engine in the adversarial
+* shape the patch must never mask: a POSITIVE production claim that
+* inverts the pool reading, healed into mechanical validity by the
+* inserted id, then caught semantically by the final judge.
+*/
+const PATCH_RUN_ID = "fault-deterministic-patch";
+const PATCH_FINAL_INVERTED_GRADED = "final: an audit-write failure does not turn success into failure and the fix is production-proven [src/exec.ts:256-296].";
 const SCENARIOS = [
 	inFlightExposure,
 	duplicateQuotaRule,
@@ -3605,134 +4105,22 @@ const SCENARIOS = [
 	parityReserveLineRedemption,
 	resumeSpawnFamine,
 	validatorGuidanceConflict,
+	repairRoundHonesty,
+	repairSurvivorRefusal,
+	repairRoundHostRejection,
+	repairRoundOwnPool,
+	repairRoundVerdictReserve,
+	repairRoundMechanicalReserve,
+	sectionalRepairRound,
+	sectionalRepairRoundFallback,
 	{
-		name: "repair-round-honesty",
-		doctrine: "the bounded post judge repair consumes the named finding (RV3307): one more composition carries the findings, the re-judge clears it, the run settles ok with the meta describing the repaired document (judgedStage 'final', findings 0, judgedHash equal to the shipped finalHash), two compositions and two final judge passes in the journal, and the invoice in the same denominator as the envelope",
-		async run() {
-			const { engine, store } = tailEngine(tailAdapter({
-				judge: (call) => call === 1 ? TAIL_FINDS : TAIL_AGREES,
-				finals: [TAIL_FINAL_INVERTED, TAIL_FINAL_CLEAN]
-			}));
-			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
-				...TAIL_OPTS,
-				claimConsistency: {
-					stage: "final",
-					onFound: "repair"
-				}
-			}), void 0, {
-				runId: "fault-repair-honesty",
-				budgetUsd: 10
-			}).result;
-			const value = outcome.value;
-			const entries = await store.load("fault-repair-honesty");
-			const { compositions, judges } = tailSpans(entries);
-			const invoice = invoiceFromJournal(entries, () => 0);
-			return {
-				observation: {
-					matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && Array.isArray(value.claimContradictions) && value.claimContradictions.length === 0 && value.claimConsistencyMeta?.judgedStage === "final" && value.claimConsistencyMeta.findings === 0 && typeof value.claimConsistencyMeta.judgedHash === "string" && value.claimConsistencyMeta.judgedHash === value.draftToFinal?.finalHash && compositions.length === 2 && judges.length === 2 && [...compositions, ...judges].every((entry) => entry.status === "ok") && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests,
-					detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the repaired document" : "an unexpected document"}; meta judgedStage='${String(value?.claimConsistencyMeta?.judgedStage)}' findings=${String(value?.claimConsistencyMeta?.findings)} judgedHash==finalHash=${String(value?.claimConsistencyMeta?.judgedHash === value?.draftToFinal?.finalHash)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es); wires ${String(outcome.envelope.wireRequests)} == invoice ` + String(invoice.cardinality.wireRequests)
-				},
-				artifacts: [jsonArtifact("outcome.json", {
-					status: outcome.status,
-					value: outcome.value ?? null,
-					envelope: outcome.envelope
-				}), jsonArtifact("journal.json", entries)]
-			};
-		}
-	},
-	{
-		name: "repair-survivor-refusal",
-		doctrine: "findings that survive the bounded repair round fail the run typed (RV3307): source 'orchestrator_claim_consistency', repairsUsed 1, preRepairHash distinct from repairedHash (the round demonstrably produced a different document and the judge still refused it), two compositions and two final judge passes paid, never a silent ok over the surviving contradiction",
-		async run() {
-			const { engine, store } = tailEngine(tailAdapter({
-				judge: () => TAIL_FINDS,
-				finals: [TAIL_FINAL_INVERTED, TAIL_FINAL_STILL_INVERTED]
-			}));
-			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
-				...TAIL_OPTS,
-				claimConsistency: {
-					stage: "final",
-					onFound: "repair"
-				}
-			}), void 0, {
-				runId: "fault-repair-survivor",
-				budgetUsd: 10
-			}).result;
-			const data = outcome.error?.data ?? {};
-			const entries = await store.load("fault-repair-survivor");
-			const { compositions, judges } = tailSpans(entries);
-			return {
-				observation: {
-					matched: outcome.status === "error" && (outcome.error?.message ?? "").includes("after the bounded repair round") && data.source === "orchestrator_claim_consistency" && data.repairsUsed === 1 && typeof data.preRepairHash === "string" && typeof data.repairedHash === "string" && data.preRepairHash !== data.repairedHash && compositions.length === 2 && judges.length === 2,
-					detail: `run '${outcome.status}': ${outcome.error?.message ?? ""}; repairsUsed=${String(data.repairsUsed)}, hashes distinct=${String(data.preRepairHash !== data.repairedHash)}, ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
-				},
-				artifacts: [jsonArtifact("outcome.json", {
-					status: outcome.status,
-					error: outcome.error ?? null
-				}), jsonArtifact("journal.json", entries)]
-			};
-		}
-	},
-	{
-		name: "repair-round-host-rejection",
-		doctrine: "a repair round that dispatched and lost its candidate to the finish contract fails typed as a host rejection (RV3601): the message names the dispatch, never 'could not dispatch'; data carries roundDispatched true, repairsUsed 1, the judge meta beside the findings, and the finish verdict verbatim (failed validators, candidateHash, candidateChars); the outcome lifts the findings beside the meta",
-		async run() {
-			const { engine, store } = tailEngine(tailAdapter({
-				judge: () => TAIL_FINDS,
-				finals: [
-					TAIL_FINAL_INVERTED,
-					TAIL_FINAL_UNGROUNDED,
-					TAIL_FINAL_UNGROUNDED
-				]
-			}));
-			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
-				...TAIL_OPTS,
-				claimConsistency: {
-					stage: "final",
-					onFound: "repair"
-				},
-				finishValidation: {
-					validators: [minMatchesValidator({
-						pattern: "src/[a-z]+\\.ts:\\d+",
-						min: 1,
-						name: "provenance-anchor"
-					})],
-					maxRepairs: 1
-				}
-			}), void 0, {
-				runId: "fault-repair-host-rejection",
-				budgetUsd: 10
-			}).result;
-			const data = outcome.error?.data ?? {};
-			const entries = await store.load("fault-repair-host-rejection");
-			const { compositions, judges } = tailSpans(entries);
-			const liftedFindings = outcome.claimContradictions;
-			const message = outcome.error?.message ?? "";
-			return {
-				observation: {
-					matched: outcome.status === "error" && message.includes("dispatched and its repaired candidate failed host validation") && !message.includes("could not dispatch") && data.source === "orchestrator_claim_consistency" && data.roundDispatched === true && data.repairsUsed === 1 && data.claimConsistencyMeta?.findings === 1 && Array.isArray(data.claimContradictions) && data.claimContradictions.length === 1 && typeof data.finishValidation?.callId === "string" && data.finishValidation.repairsUsed === 1 && data.finishValidation.maxRepairs === 1 && typeof data.finishValidation.candidateHash === "string" && typeof data.finishValidation.candidateChars === "number" && JSON.stringify(data.finishValidation.failed ?? null).includes("provenance-anchor") && Array.isArray(liftedFindings) && liftedFindings.length === 1 && compositions.length === 2 && judges.length === 1,
-					detail: `run '${outcome.status}': roundDispatched=${String(data.roundDispatched)}, repairsUsed=${String(data.repairsUsed)}, meta findings=${String(data.claimConsistencyMeta?.findings)}, finish verdict carries hash=${String(typeof data.finishValidation?.candidateHash === "string")} chars=${String(data.finishValidation?.candidateChars)}, outcome lifts findings=${String(Array.isArray(liftedFindings))}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
-				},
-				artifacts: [jsonArtifact("outcome.json", {
-					status: outcome.status,
-					error: outcome.error ?? null
-				}), jsonArtifact("journal.json", entries)]
-			};
-		}
-	},
-	{
-		name: "repair-round-own-pool",
-		doctrine: "the mechanical repair pool belongs to one composition invocation (RV3602): the bounded claim repair round enters with the full maxRepairs even after the initial composition spent its own, so the frozen third comparison sequence converges to ok/complete with verdicts repair/accepted twice and repairsUsed restarting at the invocation boundary, never a host rejection born of an inherited spent pool; the round's prompt also carries the HOST VALIDATION LESSONS block naming the failure the run already paid for (RV3603), while the initial composition carries none",
+		name: "deterministic-provenance-patch",
+		doctrine: "the finish loop performs the evidence-grade prescription host side (RV3801): a candidate whose every failure carries repair hints is patched without a provider wire and accepted with the mechanical pool untouched, the healed failure still teaches the repair round through HOST VALIDATION LESSONS, and the claim judge rules on the PATCHED document, so an inserted id satisfies provenance mechanics but never masks a false positive production claim",
 		async run() {
 			let judgeCalls = 0;
 			const adapter = tailAdapter({
 				judge: () => (judgeCalls += 1) === 1 ? TAIL_FINDS : TAIL_AGREES,
-				finals: [
-					TAIL_FINAL_UNGROUNDED_INITIAL,
-					TAIL_FINAL_INVERTED,
-					TAIL_FINAL_UNGROUNDED,
-					TAIL_FINAL_CLEAN
-				]
+				finals: [PATCH_FINAL_INVERTED_GRADED, TAIL_FINAL_CLEAN]
 			});
 			const { engine, store } = tailEngine(adapter);
 			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
@@ -3742,29 +4130,28 @@ const SCENARIOS = [
 					onFound: "repair"
 				},
 				finishValidation: {
-					validators: [minMatchesValidator({
-						pattern: "src/[a-z]+\\.ts:\\d+",
-						min: 1,
-						name: "provenance-anchor"
-					})],
+					validators: [evidenceGradeValidator({ artifactPattern: "run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}" })],
 					maxRepairs: 1
 				}
 			}), void 0, {
-				runId: "fault-repair-own-pool",
+				runId: PATCH_RUN_ID,
 				budgetUsd: 10
 			}).result;
 			const value = outcome.value;
-			const entries = await store.load("fault-repair-own-pool");
+			const entries = await store.load(PATCH_RUN_ID);
 			const { compositions, judges } = tailSpans(entries);
 			const verdictRows = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value);
 			const verdicts = verdictRows.map((row) => row.verdict).join(",");
 			const pools = verdictRows.map((row) => String(row.repairsUsed)).join(",");
-			const compositionPrompts = adapter.calls.filter((call) => call.label === "final-composition").map((call) => call.prompt);
-			const lessonCarried = compositionPrompts.length === 4 && compositionPrompts[0]?.includes("HOST VALIDATION LESSONS") === false && compositionPrompts[2]?.includes("HOST VALIDATION LESSONS") === true && compositionPrompts[2]?.includes("provenance-anchor") === true;
+			const patch = verdictRows[0]?.deterministicRepair;
+			const judgeSawPatched = adapter.calls.filter((call) => call.label === "claim-consistency-judge-final").map((call) => call.prompt)[0]?.includes(`(run ${PATCH_RUN_ID})`) === true;
+			const roundPrompts = adapter.calls.filter((call) => call.label === "final-composition").map((call) => call.prompt);
+			const lessonCarried = roundPrompts.length === 2 && roundPrompts[0]?.includes("HOST VALIDATION LESSONS") === false && roundPrompts[1]?.includes("HOST VALIDATION LESSONS") === true && roundPrompts[1]?.includes("evidence-grade") === true;
+			const aggregate = value?.deterministicPatches?.decisions === 1 && typeof value.deterministicPatches.patches === "number" && value.deterministicPatches.patches >= 1 && /^[0-9a-f]{64}$/u.test(String(value.deterministicPatches.lastAfterHash)) && value.deterministicPatches.lastAfterHash !== value.deterministicPatches.lastBeforeHash;
 			return {
 				observation: {
-					matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && value.claimConsistencyMeta?.findings === 0 && verdicts === "repair,accepted,repair,accepted" && pools === "0,1,0,1" && (value.rejectedFinishCandidates?.length ?? 0) === 2 && value.rejectedFinishCandidates?.every((row) => row.verdict === "repair") === true && lessonCarried && compositions.length === 2 && judges.length === 2,
-					detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the repaired document" : "an unexpected document"}; verdicts [${verdicts}], repairsUsed [${pools}] (fresh pool at the invocation boundary); lesson carried=${String(lessonCarried)}; meta findings=${String(value?.claimConsistencyMeta?.findings)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+					matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && value.claimConsistencyMeta?.findings === 0 && aggregate && verdicts === "accepted,accepted" && pools === "0,0" && patch?.outcome === "accepted" && patch.healed?.map((healed) => healed.name).join(",") === "evidence-grade" && judgeSawPatched && lessonCarried && compositions.length === 2 && judges.length === 2,
+					detail: `run '${outcome.status}' shipped ${value?.result === TAIL_FINAL_CLEAN ? "the clean round document" : "an unexpected document"}; verdicts [${verdicts}], repairsUsed [${pools}] (no wire, no pool spent); patch outcome='${String(patch?.outcome)}'; envelope aggregate=${String(aggregate)}; judge saw patched=${String(judgeSawPatched)}; lesson carried=${String(lessonCarried)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
 				},
 				artifacts: [jsonArtifact("outcome.json", {
 					status: outcome.status,
@@ -3774,95 +4161,103 @@ const SCENARIOS = [
 			};
 		}
 	},
+	claimJudgeDeadArmedRefusal,
 	{
-		name: "repair-round-verdict-reserve",
-		doctrine: "the repair round pays for its verdict up front (RV3701): the money of the round second judge pass (the declared judge estCost first, else the run own observed post draft judge price) is held from the moment the round is admitted, a round the budget can only start refuses through the honest pre dispatch class before any of its wires with the held convergence reserve named in the refusal arithmetic, and exactly one composition is ever paid for",
+		name: "acceptance-reserve-refusal",
+		doctrine: "budget.acceptanceReserve 'require' refuses the run typed BEFORE the first wire when the declared acceptance tail (synthesis hold + judge passes + mechanical repair + round composition + working room) does not fit the effective cap, and the refusal journals every term; the same config under the default warn posture dispatches",
 		async run() {
-			const { engine, store } = tailEngine(tailAdapter({
-				judge: () => TAIL_FINDS,
-				finals: [TAIL_FINAL_INVERTED]
-			}));
-			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
-				...TAIL_OPTS,
-				synthesis: {
-					limits: { maxTurns: 3 },
-					estCost: .2
-				},
-				budget: {
-					capUsd: .3,
-					capFraction: 1
-				},
+			const store = new InMemoryStore();
+			const adapter = new FakeAdapter({ agents: { "*": "never dispatched" } });
+			const outcome = await createEngine({
+				adapters: [adapter],
+				stores: { journal: store },
+				defaults: { routing: {
+					loop: FAKE_MODEL_REF,
+					orchestrate: FAKE_MODEL_REF,
+					synthesize: FAKE_MODEL_REF,
+					extract: FAKE_MODEL_REF
+				} }
+			}).run(makeOrchestratorWorkflow("audit the executor", {
+				synthesis: { estCost: .15 },
 				claimConsistency: {
 					stage: "final",
 					onFound: "repair",
 					judge: { estCost: .2 }
+				},
+				finishValidation: {
+					validators: [{
+						name: "anything",
+						validate: () => ({ ok: true })
+					}],
+					estRepairCostUsd: .1
+				},
+				budget: {
+					synthesisReserveUsd: 1,
+					acceptanceReserve: "require"
 				}
 			}), void 0, {
-				runId: "fault-repair-verdict-reserve",
+				runId: "fault-acceptance-reserve",
 				budgetUsd: 10
 			}).result;
-			const data = outcome.error?.data ?? {};
-			const entries = await store.load("fault-repair-verdict-reserve");
-			const { compositions, judges } = tailSpans(entries);
-			const message = outcome.error?.message ?? "";
-			const holdNamed = message.includes("held convergence reserve 0.2000");
+			const refusal = (await store.load("fault-acceptance-reserve")).find((entry) => entry.value?.decisionType === "acceptance_reserve_refused");
+			const terms = refusal?.value;
 			return {
 				observation: {
-					matched: outcome.status === "error" && message.includes("could not dispatch") && holdNamed && data.source === "orchestrator_claim_consistency" && data.roundDispatched === false && data.repairsUsed === 0 && data.claimConsistencyMeta?.findings === 1 && compositions.length === 1 && judges.length === 1,
-					detail: `run '${outcome.status}': roundDispatched=${String(data.roundDispatched)}, repairsUsed=${String(data.repairsUsed)}, held convergence reserve named=${String(holdNamed)}; ${String(compositions.length)} composition(s) paid, ${String(judges.length)} final judge pass(es)`
+					matched: outcome.status === "error" && (outcome.error?.message ?? "").includes("acceptanceReserve 'require'") && adapter.calls.length === 0 && terms !== void 0 && Math.abs((terms.requiredUsd ?? 0) - 2.15) < 1e-9 && Math.abs((terms.effectiveCapUsd ?? 0) - 2) < 1e-9 && terms.judgePasses === 2,
+					detail: `run '${outcome.status}'; dispatches=${String(adapter.calls.length)}; refusal decision=${String(refusal !== void 0)} (required ${String(terms?.requiredUsd)} vs cap ${String(terms?.effectiveCapUsd)}, ` + `judge passes ${String(terms?.judgePasses)}); ${outcome.error?.message ?? ""}`.slice(0, 400)
 				},
-				artifacts: [jsonArtifact("outcome.json", {
-					status: outcome.status,
-					error: outcome.error ?? null
-				}), jsonArtifact("journal.json", entries)]
+				artifacts: [jsonArtifact("refusal.json", {
+					error: outcome.error ?? null,
+					decision: refusal?.value ?? null
+				})]
 			};
 		}
 	},
 	{
-		name: "claim-judge-dead-armed-refusal",
-		doctrine: "a final stage judge that dies on the wire under an armed posture fails the run typed for both 'fail' and 'repair' (RV3307), each message naming its armed posture, with exactly one composition paid and no repair round dispatched, never a silent settle over findings nobody ruled on",
+		name: "budget-policy-immutable",
+		doctrine: "budgetPolicy 'immutable-lifetime' refuses a resume-time ceiling override typed before ownership, raise and lower alike, with zero provider dispatches and zero durable mutations; a bare resume of the same run stays a pure replay",
 		async run() {
-			const judgeDeath = () => fakeWireError({
-				code: "agent",
-				message: "the judge died mid stream",
-				retryable: false,
-				data: {}
-			});
-			const runs = [];
-			const journals = {};
-			for (const posture of ["fail", "repair"]) {
-				const { engine, store } = tailEngine(tailAdapter({
-					judge: judgeDeath,
-					finals: [TAIL_FINAL_INVERTED]
-				}));
-				const runId = `fault-dead-judge-${posture}`;
-				const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
-					...TAIL_OPTS,
-					claimConsistency: {
-						stage: "final",
-						onFound: posture
-					}
-				}), void 0, {
-					runId,
-					budgetUsd: 10
-				}).result;
-				const entries = await store.load(runId);
-				const { compositions, judges } = tailSpans(entries);
-				journals[posture] = entries;
-				runs.push({
-					posture,
-					status: outcome.status,
-					message: outcome.error?.message ?? "",
-					compositions: compositions.length,
-					judges: judges.length
-				});
+			const store = new InMemoryStore();
+			const seeded = await createEngine({
+				adapters: [new FakeAdapter({ agents: { "*": "answered" } })],
+				stores: { journal: store },
+				defaults: ROUTING
+			}).run(echoWorkflow, void 0, {
+				runId: "fault-budget-policy",
+				budgetUsd: 1,
+				budgetPolicy: "immutable-lifetime"
+			}).result;
+			const entriesBefore = (await store.load("fault-budget-policy")).length;
+			const overrideAdapter = new FakeAdapter({ agents: { "*": "never dispatched" } });
+			let refusalText = "the override was not refused";
+			let refusedTyped = false;
+			try {
+				await createEngine({
+					adapters: [overrideAdapter],
+					stores: { journal: store },
+					defaults: ROUTING
+				}).resume("fault-budget-policy", echoWorkflow, { run: { budgetUsd: 2 } }).result;
+			} catch (thrown) {
+				refusalText = errorText(thrown);
+				refusedTyped = thrown instanceof ConfigError && refusalText.includes("immutable-lifetime");
 			}
+			const entriesAfterRefusal = (await store.load("fault-budget-policy")).length;
+			const metaAfterRefusal = await store.getMeta("fault-budget-policy");
+			const bare = await createEngine({
+				adapters: [new FakeAdapter({ agents: { "*": "never dispatched either" } })],
+				stores: { journal: store },
+				defaults: ROUTING
+			}).resume("fault-budget-policy", echoWorkflow).result;
 			return {
 				observation: {
-					matched: runs.every((run) => run.status === "error" && run.message.includes(`armed ${run.posture} posture`) && run.compositions === 1 && run.judges === 1),
-					detail: runs.map((run) => `${run.posture}: '${run.status}' (${run.compositions} composition(s), ${run.judges} judge span(s)) ${run.message.slice(0, 120)}`).join(" | ")
+					matched: seeded.status === "ok" && refusedTyped && overrideAdapter.calls.length === 0 && entriesAfterRefusal === entriesBefore && metaAfterRefusal?.budgetUsd === 1 && metaAfterRefusal.budgetPolicy === "immutable-lifetime" && bare.status === "ok",
+					detail: `seed '${seeded.status}'; refusal typed=${String(refusedTyped)} (${refusalText.slice(0, 160)}); override dispatches=${String(overrideAdapter.calls.length)}; entries ${String(entriesBefore)} -> ${String(entriesAfterRefusal)}; meta budgetUsd=${String(metaAfterRefusal?.budgetUsd)} policy=${String(metaAfterRefusal?.budgetPolicy)}; bare resume '${bare.status}'`
 				},
-				artifacts: [jsonArtifact("runs.json", runs), jsonArtifact("journals.json", journals)]
+				artifacts: [jsonArtifact("refusal.json", {
+					refusalText,
+					entriesBefore,
+					entriesAfterRefusal
+				}), jsonArtifact("meta.json", metaAfterRefusal ?? null)]
 			};
 		}
 	}
@@ -4040,6 +4435,64 @@ const CLAIM_CORPUS = [
 		},
 		runFactTerms: ["in total", "end to end"],
 		expect: { minRunFactPairs: 1 }
+	},
+	{
+		id: "bound-conflation-mcp-caps-guards",
+		class: "bound-conflation",
+		draft: "MCP resource reads are bounded unconditionally: byte caps, page caps, and the cursor guards all refuse oversized or cyclic reads by default (packages/core/src/tools/mcp.ts:44).",
+		pool: [{
+			nodeId: "agent:2",
+			text: "The MCP read caps are OPT-IN: an absent maxResourceBytes or maxResourcePages means unbounded, and only requireBounds: true refuses their absence (packages/core/src/tools/mcp.ts:44-57). The cursor echo and visited-cursor guards are the unconditional half: they refuse a cycle regardless of any cap (packages/core/src/tools/mcp.ts:168-174)."
+		}],
+		critical: ["packages/core/src/tools/mcp.ts"],
+		expect: {
+			minPairs: 1,
+			anchors: ["packages/core/src/tools/mcp.ts:44"],
+			coverage: "full"
+		}
+	},
+	{
+		id: "derived-premise-slot-arithmetic",
+		class: "derived-premise",
+		draft: "The gateway sustains 2000 slots per burst window, a figure derived from the 30 minute window at the recorded admission rate.",
+		runFacts: {
+			text: "The declared burst window is 20 minutes end to end; at the recorded admission rate a 20 minute window admits 1333 slots, and 2000 slots would require the 30 minute window no configuration declares.",
+			ids: ["comparison-run-aug13"],
+			numbers: [
+				20,
+				1333,
+				2e3
+			]
+		},
+		runFactTerms: ["2000 slots", "30 minute window"],
+		expect: { minRunFactPairs: 1 }
+	},
+	{
+		id: "cost-basis-local-estimate-as-bill",
+		class: "cost-basis",
+		draft: "The provider bill for the whole workflow came to 5.5807 USD, charged and settled by the provider for this run.",
+		runFacts: {
+			text: "The invoice cost basis is 'locally-estimated': recorded usage priced at the pinned local rate table; no provider statement was reconciled for this run and no charged amount was recorded.",
+			ids: ["comparison-run-aug13"],
+			numbers: []
+		},
+		runFactTerms: ["provider bill", "charged and settled"],
+		expect: { minRunFactPairs: 1 }
+	},
+	{
+		id: "stale-doctrine-echo-budget-override",
+		class: "stale-doctrine-echo",
+		draft: "The run budget ceiling is documented as immutable after start: resume accepts no budget parameter, so an exhausted run can never continue under a raised ceiling (docs/guide/budgets.md:43; packages/core/src/engine/engine.ts:588).",
+		pool: [{
+			nodeId: "agent:3",
+			text: "The budgets guide historically taught \"immutable after start\" (docs/guide/budgets.md:43), but ResumeOptions.run raises budgetUsd and maxInFlightExposureUsd at resume, validated and journaled as a run_budget_override decision with a typed floor at the settled spend (packages/core/src/engine/engine.ts:588-604); the doctrine in force is immutability WITHIN a segment."
+		}],
+		critical: ["packages/core/src/engine/engine.ts"],
+		expect: {
+			minPairs: 1,
+			anchors: ["packages/core/src/engine/engine.ts:588"],
+			coverage: "full"
+		}
 	}
 ];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/evals",
-  "version": "1.242.0",
+  "version": "1.244.0",
   "description": "Rulvar evals: eval cases, golden outputs, rubric and judge graders, matrix sweeps, canary fingerprint.",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,11 +22,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/anthropic": "1.242.0",
-    "@rulvar/core": "1.242.0",
-    "@rulvar/openai": "1.242.0",
-    "@rulvar/plan": "1.242.0",
-    "@rulvar/testing": "1.242.0"
+    "@rulvar/anthropic": "1.244.0",
+    "@rulvar/openai": "1.244.0",
+    "@rulvar/core": "1.244.0",
+    "@rulvar/plan": "1.244.0",
+    "@rulvar/testing": "1.244.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",