@rulvar/evals 1.243.0 → 1.245.0

package/dist/index.d.ts

@@ -849,9 +849,14 @@ declare function runFaultInjection(options?: RunFaultInjectionOptions): Promise<
 * 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 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" | "bound-conflation" | "derived-premise" | "cost-basis";
+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

@@ -3950,12 +3950,14 @@ const sectionalRepairRound = {
 		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;
+		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;
+		const ledger = value?.repairs?.draft === 0 && value.repairs.composition === 0 && value.repairs.semantic === 1 && value.repairs.total === 1;
 		return {
 			observation: {
-				matched: outcome.status === "ok" && byteIdentity && value.claimConsistencyMeta?.findings === 0 && 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)}; verdicts [${verdictRows.map((row) => row.verdict).join(",")}]; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+				matched: outcome.status === "ok" && byteIdentity && value.claimConsistencyMeta?.findings === 0 && lineage && ledger && 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)}; ledger=${String(ledger)}; 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,
@@ -4076,6 +4078,341 @@ const claimJudgeDeadArmedRefusal = {
 */
 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 deterministicProvenancePatch = {
+	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: [PATCH_FINAL_INVERTED_GRADED, 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: [evidenceGradeValidator({ artifactPattern: "run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}" })],
+				maxRepairs: 1
+			}
+		}), void 0, {
+			runId: PATCH_RUN_ID,
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		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 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 && 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,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+/**
+* RV3902: budgetPolicy 'immutable-lifetime' welds the RV2208 override
+* door shut. A resume carrying any applying ResumeOptions.run refuses
+* typed BEFORE ownership, meta writes, or any append, raise and lower
+* alike, with zero provider dispatches; a bare resume of the same run
+* stays an ordinary pure replay, because the posture pins the
+* ceilings, never the resume.
+*/
+const budgetPolicyImmutable = {
+	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 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: 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("refusal.json", {
+				refusalText,
+				entriesBefore,
+				entriesAfterRefusal
+			}), jsonArtifact("meta.json", metaAfterRefusal ?? null)]
+		};
+	}
+};
+/**
+* RV3907: budget.acceptanceReserve 'require' turns the two preflight
+* warning classes (`reserve-line-headroom`, `orchestrator-working-room`)
+* into a typed boot refusal BEFORE the first wire: the declared
+* acceptance tail must fit the effective cap at exact fill or better,
+* and the refusal journals its arithmetic term by term.
+*/
+const acceptanceReserveRefusal = {
+	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 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-acceptance-reserve",
+			budgetUsd: 10
+		}).result;
+		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" && (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("refusal.json", {
+				error: outcome.error ?? null,
+				decision: refusal?.value ?? null
+			})]
+		};
+	}
+};
+const DRAFT_REPAIR_BROKEN = `${SECTIONAL_PREFIX}## Verdict\n\nfinal: the audit path is safe.
+`;
+const DRAFT_REPAIR_VERDICT_BODY = "final: the audit path is safe [src/exec.ts:256-296].\n";
+const DRAFT_REPAIR_FINAL = `${SECTIONAL_PREFIX}## Verdict\n\nfinal: the audit path is safe, composed over the healed draft [src/exec.ts:256-296].
+`;
+const coordinationDraftRepair = {
+	name: "coordination-draft-repair",
+	doctrine: "the workflow repair ledger counts the draft gate (RV4002): a coordination draft rejected by the contract gate and healed by a sectional resubmission is ONE draft repair on the envelope ({draft: 1, composition: 0, semantic: 0, total: 1}) with the rejected validators, the resubmitted sections, and the repair wire named; the fifth comparison run's judge rebuilt exactly this count from the raw transcript because no aggregate would answer for the workflow",
+	async run() {
+		let loopTurns = 0;
+		const adapter = new FakeAdapter({ agents: {
+			"final-composition": () => fakeToolCalls({
+				name: "finish",
+				args: { result: DRAFT_REPAIR_FINAL }
+			}),
+			"*": () => {
+				loopTurns += 1;
+				return loopTurns === 1 ? fakeToolCalls({
+					name: "finish",
+					args: { result: DRAFT_REPAIR_BROKEN }
+				}) : fakeToolCalls({
+					name: "finish",
+					args: { sections: { "## Verdict": DRAFT_REPAIR_VERDICT_BODY } }
+				});
+			}
+		} });
+		const store = new InMemoryStore();
+		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
+				},
+				billingReceipts: "awaited"
+			}
+		}).run(makeOrchestratorWorkflow("audit the executor", {
+			...TAIL_OPTS,
+			finishValidation: {
+				validators: [minMatchesValidator({
+					pattern: "src/[a-z]+\\.ts:\\d+",
+					min: 1,
+					name: "provenance-anchor"
+				})],
+				maxRepairs: 1,
+				draftPolicy: "contract",
+				sectionalRepair: { sections: ["## Verdict"] }
+			}
+		}), void 0, {
+			runId: "fault-draft-repair",
+			budgetUsd: 10
+		}).result;
+		const value = outcome.value;
+		const entries = await store.load("fault-draft-repair");
+		const gateRows = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_draft_gate").map((entry) => entry.value);
+		const repairWires = entries.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "provider-call" && entry.value.record?.phase === "repair");
+		const ledger = value?.repairs?.draft === 1 && value.repairs.composition === 0 && value.repairs.semantic === 0 && value.repairs.total === 1;
+		const row = value?.repairs?.rounds?.[0];
+		const rowFacts = row?.stage === "draft" && Array.isArray(row.failedValidators) && row.failedValidators.join(",") === "provenance-anchor" && Array.isArray(row.sections) && row.sections.join(",") === "## Verdict" && typeof row.wireRef === "number";
+		const gateFacts = gateRows.map((gate) => gate.verdict).join(",") === "rejected,accepted" && gateRows[0]?.failed?.map((f) => f.name).join(",") === "provenance-anchor" && gateRows[1]?.sections?.join(",") === "## Verdict";
+		return {
+			observation: {
+				matched: outcome.status === "ok" && value?.result === DRAFT_REPAIR_FINAL && ledger && rowFacts && gateFacts && repairWires.length === 1,
+				detail: `run '${outcome.status}'; ledger=${String(ledger)}; row=${String(rowFacts)}; gate decisions [${gateRows.map((gate) => gate.verdict).join(",")}]; ${String(repairWires.length)} repair-stamped wire(s)`
+			},
+			artifacts: [jsonArtifact("outcome.json", {
+				status: outcome.status,
+				value: outcome.value ?? null,
+				envelope: outcome.envelope
+			}), jsonArtifact("journal.json", entries)]
+		};
+	}
+};
+const COVERAGE_POOL = "A failed audit write does not mask success (`src/exec.ts:256-296`).";
+const COVERAGE_FINAL_PARTIAL = "final: an audit-write failure does not mask success [src/exec.ts:256-296]. final: the retry ladder caps at three attempts [src/retry.ts:24].";
+const strictCoveragePolicy = {
+	name: "strict-coverage-policy",
+	doctrine: "coveragePolicy 'strict-final' turns the coverage grade into a gate (RV4003): a final grade of 'partial' refuses acceptance typed with the grade named, and the SAME run under a declared waiver settles ok with claim_coverage_waived journaled and the waiver riding the envelope verbatim, so a non-full grade on a strict run always names who accepted it and why",
+	async run() {
+		const makeAdapter = () => {
+			let loopTurns = 0;
+			return new FakeAdapter({ agents: {
+				"claim-consistency-judge-final": JSON.stringify({ contradictions: [] }),
+				"final-composition": () => fakeToolCalls({
+					name: "finish",
+					args: { result: COVERAGE_FINAL_PARTIAL }
+				}),
+				worker: COVERAGE_POOL,
+				"*": (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: "draft before synthesis" }
+					});
+				}
+			} });
+		};
+		const strictOpts = {
+			...TAIL_OPTS,
+			claimConsistency: {
+				stage: "final",
+				coveragePolicy: "strict-final"
+			}
+		};
+		const refused = await tailEngine(makeAdapter()).engine.run(makeOrchestratorWorkflow("audit the executor", strictOpts), void 0, {
+			runId: "fault-strict-coverage-refused",
+			budgetUsd: 10
+		}).result;
+		const refusedData = refused.error?.data;
+		const refusedTyped = refused.status === "error" && refusedData?.source === "orchestrator_claim_consistency" && refusedData.coveragePolicy === "strict-final" && refusedData.coverage === "partial";
+		const waivedRig = tailEngine(makeAdapter());
+		const waived = await waivedRig.engine.run(makeOrchestratorWorkflow("audit the executor", {
+			...strictOpts,
+			claimConsistency: {
+				...strictOpts.claimConsistency,
+				waiver: {
+					principal: "release-owner",
+					reason: "the uncovered anchor is a legacy path scheduled for removal"
+				}
+			}
+		}), void 0, {
+			runId: "fault-strict-coverage-waived",
+			budgetUsd: 10
+		}).result;
+		const waivedValue = waived.value;
+		const waivedDecision = (await waivedRig.store.load("fault-strict-coverage-waived")).find((entry) => entry.value?.decisionType === "claim_coverage_waived");
+		const waivedOk = waived.status === "ok" && waivedValue?.claimConsistencyMeta?.coverage === "partial" && waivedValue.claimCoverageWaiver?.principal === "release-owner" && waivedValue.claimCoverageWaiver.coverage === "partial" && waivedDecision !== void 0;
+		return {
+			observation: {
+				matched: refusedTyped && waivedOk,
+				detail: `strict refusal typed=${String(refusedTyped)} (status '${refused.status}', coverage '${String(refusedData?.coverage)}'); waived settle=${String(waivedOk)} (status '${waived.status}', principal '${String(waivedValue?.claimCoverageWaiver?.principal)}', decision journaled=${String(waivedDecision !== void 0)})`
+			},
+			artifacts: [jsonArtifact("refused.json", {
+				status: refused.status,
+				error: refused.error ?? null
+			}), jsonArtifact("waived.json", {
+				status: waived.status,
+				value: waived.value ?? null
+			})]
+		};
+	}
+};
+const AUDIT_SNAPSHOT = {
+	"src/otel.ts:18": "attributes: dropUnknown(config.exporter),",
+	"src/otel.ts:19": "batchWindowMs: 500,",
+	"src/retry.ts:24": "const MAX_ATTEMPTS = 3;"
+};
+const AUDIT_RESOLVE = (target) => AUDIT_SNAPSHOT[`${target.path}:${String(target.line)}`];
+const AUDIT_FINAL = [
+	"# Audit",
+	"",
+	"## Grid",
+	"",
+	"No SLO observations exist anywhere in the exporter [src/otel.ts:18].",
+	"",
+	"## Verdict",
+	"",
+	"The retry ladder caps at three attempts [src/retry.ts:24]."
+].join("\n");
 const SCENARIOS = [
 	inFlightExposure,
 	duplicateQuotaRule,
@@ -4112,54 +4449,137 @@ const SCENARIOS = [
 	repairRoundMechanicalReserve,
 	sectionalRepairRound,
 	sectionalRepairRoundFallback,
+	coordinationDraftRepair,
 	{
-		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",
+		name: "citation-entailment-audit",
+		doctrine: "the citation audit reads the cited lines and judges entailment (RV4004): a citation that is mechanically valid and value-clean but not entailed by its lines is a named finding with the section and reason on the envelope, the supported control stays clean, and the armed 'fail' posture stops the run typed; the fifth comparison run shipped three exactly such citations past every built-in verifier",
 		async run() {
-			let judgeCalls = 0;
-			const adapter = tailAdapter({
-				judge: () => (judgeCalls += 1) === 1 ? TAIL_FINDS : TAIL_AGREES,
-				finals: [PATCH_FINAL_INVERTED_GRADED, TAIL_FINAL_CLEAN]
-			});
-			const { engine, store } = tailEngine(adapter);
-			const outcome = await engine.run(makeOrchestratorWorkflow("audit the executor", {
+			const makeAdapter = () => new FakeAdapter({ agents: {
+				"citation-entailment-judge": JSON.stringify({ verdicts: [{
+					row: 0,
+					verdict: "unsupported",
+					reason: "the line sets an exporter attribute policy, not observation absence"
+				}, {
+					row: 1,
+					verdict: "supported",
+					reason: "the line pins the attempts constant"
+				}] }),
+				"final-composition": () => fakeToolCalls({
+					name: "finish",
+					args: { result: AUDIT_FINAL }
+				}),
+				"*": () => fakeToolCalls({
+					name: "finish",
+					args: { result: "the coordination draft" }
+				})
+			} });
+			const reported = await tailEngine(makeAdapter()).engine.run(makeOrchestratorWorkflow("audit the executor", {
 				...TAIL_OPTS,
-				claimConsistency: {
-					stage: "final",
-					onFound: "repair"
-				},
-				finishValidation: {
-					validators: [evidenceGradeValidator({ artifactPattern: "run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}" })],
-					maxRepairs: 1
+				citationAudit: { resolve: AUDIT_RESOLVE }
+			}), void 0, {
+				runId: "fault-citation-audit-report",
+				budgetUsd: 10
+			}).result;
+			const reportedValue = reported.value;
+			const reportedOk = reported.status === "ok" && reportedValue?.citationAuditMeta?.sampled === 2 && reportedValue.citationAuditMeta.supported === 1 && reportedValue.citationAuditMeta.unsupported === 1 && reportedValue.citationAuditMeta.judgeInvoked === true && reportedValue.citationFindings?.length === 1 && reportedValue.citationFindings[0]?.verdict === "unsupported" && reportedValue.citationFindings[0].anchor === "src/otel.ts:18" && reportedValue.citationFindings[0].section === "## Grid";
+			const failed = await tailEngine(makeAdapter()).engine.run(makeOrchestratorWorkflow("audit the executor", {
+				...TAIL_OPTS,
+				citationAudit: {
+					resolve: AUDIT_RESOLVE,
+					onFound: "fail"
 				}
 			}), void 0, {
-				runId: PATCH_RUN_ID,
+				runId: "fault-citation-audit-fail",
 				budgetUsd: 10
 			}).result;
-			const value = outcome.value;
-			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 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 failData = failed.error?.data;
+			const failTyped = failed.status === "error" && failData?.source === "orchestrator_citation_audit" && (failed.error?.message ?? "").includes("UNSUPPORTED");
 			return {
 				observation: {
-					matched: outcome.status === "ok" && value?.result === TAIL_FINAL_CLEAN && value.claimConsistencyMeta?.findings === 0 && 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)}'; judge saw patched=${String(judgeSawPatched)}; lesson carried=${String(lessonCarried)}; ${String(compositions.length)} composition(s), ${String(judges.length)} final judge pass(es)`
+					matched: reportedOk && failTyped,
+					detail: `report arm=${String(reportedOk)} (status '${reported.status}', sampled ${String(reportedValue?.citationAuditMeta?.sampled)}, unsupported ${String(reportedValue?.citationAuditMeta?.unsupported)}); fail arm typed=${String(failTyped)} (status '${failed.status}')`
 				},
-				artifacts: [jsonArtifact("outcome.json", {
-					status: outcome.status,
-					value: outcome.value ?? null,
-					envelope: outcome.envelope
-				}), jsonArtifact("journal.json", entries)]
+				artifacts: [jsonArtifact("reported.json", {
+					status: reported.status,
+					value: reported.value ?? null
+				}), jsonArtifact("failed.json", {
+					status: failed.status,
+					error: failed.error ?? null
+				})]
 			};
 		}
 	},
-	claimJudgeDeadArmedRefusal
+	deterministicProvenancePatch,
+	claimJudgeDeadArmedRefusal,
+	strictCoveragePolicy,
+	acceptanceReserveRefusal,
+	budgetPolicyImmutable,
+	{
+		name: "wire-intent-unknown-outcome",
+		doctrine: "billingReceipts 'intent' journals a provider-intent before every dispatched wire attempt (RV4006), and a resume that finds one with no receipt and no terminal coverage refuses the blind retry typed; the acknowledged resume journals the override and the invoice names the wire in its openIntents lane, with no invented dollars, because the outcome is exactly what the process does not know",
+		async run() {
+			const dir = mkdtempSync(join(tmpdir(), "rulvar-fault-intent-"));
+			const makeRig = () => {
+				const store = new JsonlFileStore({ dir });
+				return {
+					engine: createEngine({
+						adapters: [new FakeAdapter({ agents: { "*": "stored answer" } })],
+						stores: { journal: store },
+						defaults: {
+							...ROUTING,
+							billingReceipts: "intent"
+						}
+					}),
+					store
+				};
+			};
+			const first = makeRig();
+			const seeded = await first.engine.run(echoWorkflow, void 0, {
+				runId: "fault-wire-intent",
+				budgetUsd: 5
+			}).result;
+			const intentRows = (await first.store.load("fault-wire-intent")).filter((entry) => entry.value?.decisionType === "provider-intent");
+			const file = readdirSync(dir).filter((name) => name.includes("fault-wire-intent") && name.endsWith(".jsonl")).map((name) => join(dir, name))[0];
+			if (file === void 0) throw new Error("fault kit: no journal file for the intent scenario");
+			const lines = readFileSync(file, "utf8").trim().split("\n");
+			const orphan = {
+				seq: Math.max(...lines.map((line) => JSON.parse(line).seq)) + 1,
+				kind: "decision",
+				scope: "",
+				key: "pi:99999:1:1",
+				status: "ok",
+				spanId: "crash-window",
+				site: "provider-intent",
+				value: {
+					decisionType: "provider-intent",
+					agentRef: 99999,
+					ordinal: 1,
+					attempt: 1,
+					servedBy: FAKE_MODEL_REF,
+					requestFingerprint: "f".repeat(64)
+				}
+			};
+			writeFileSync(file, `${lines.join("\n")}\n${JSON.stringify(orphan)}\n`, "utf8");
+			const lane = invoiceFromJournal(await new JsonlFileStore({ dir }).load("fault-wire-intent"), () => .001).openIntents;
+			let refusedTyped = false;
+			let refusedMessage = "";
+			try {
+				await makeRig().engine.resume("fault-wire-intent", echoWorkflow).result;
+			} catch (thrown) {
+				refusedMessage = thrown instanceof Error ? thrown.message : String(thrown);
+				refusedTyped = thrown instanceof Error && thrown.name === "ConfigError" && refusedMessage.includes("unknown outcome") && refusedMessage.includes("acknowledgeOpenWireIntents");
+			}
+			const acked = await makeRig().engine.resume("fault-wire-intent", echoWorkflow, { acknowledgeOpenWireIntents: true }).result;
+			const ackDecision = (await new JsonlFileStore({ dir }).load("fault-wire-intent")).find((entry) => entry.value?.decisionType === "open_wire_intents_acknowledged");
+			return {
+				observation: {
+					matched: seeded.status === "ok" && intentRows.length > 0 && lane?.count === 1 && lane.rows[0]?.agentRef === 99999 && refusedTyped && acked.status === "ok" && ackDecision !== void 0,
+					detail: `seed '${seeded.status}' with ${String(intentRows.length)} intent row(s); lane count=${String(lane?.count)}; refusal typed=${String(refusedTyped)}; acknowledged resume '${acked.status}' with decision journaled=${String(ackDecision !== void 0)}`
+				},
+				artifacts: [jsonArtifact("refusal.json", { message: refusedMessage }), jsonArtifact("lane.json", lane ?? null)]
+			};
+		}
+	}
 ];
 /** The scenario names in run order. */
 const FAULT_SCENARIO_NAMES = SCENARIOS.map((scenario) => scenario.name);
@@ -4377,6 +4797,21 @@ const CLAIM_CORPUS = [
 		},
 		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.243.0",
+  "version": "1.245.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/core": "1.243.0",
-    "@rulvar/openai": "1.243.0",
-    "@rulvar/testing": "1.243.0",
-    "@rulvar/anthropic": "1.243.0",
-    "@rulvar/plan": "1.243.0"
+    "@rulvar/openai": "1.245.0",
+    "@rulvar/plan": "1.245.0",
+    "@rulvar/anthropic": "1.245.0",
+    "@rulvar/testing": "1.245.0",
+    "@rulvar/core": "1.245.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",