@rulvar/evals 1.238.0 → 1.239.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { join } from "node:path";
 import { ANTHROPIC_PRICING, anthropic } from "@rulvar/anthropic";
 import { reconcileStatement } from "@rulvar/openai";
 import { orchestratePlanned } from "@rulvar/plan";
-import { FAKE_MODEL_REF, FakeAdapter, fakeToolCalls } from "@rulvar/testing";
+import { FAKE_MODEL_REF, FakeAdapter, fakeToolCalls, fakeWireError } from "@rulvar/testing";
 //#region src/envelope.ts
 /**
 * The debit-only aggregate spend envelope (v1.16.2 review P1-2). A
@@ -3107,305 +3107,171 @@ const scriptedCaps = () => ({
 		outputUsdPerMTok: 10
 	}
 });
-const SCENARIOS = [
-	inFlightExposure,
-	duplicateQuotaRule,
-	tornJsonlTail,
-	gluedJsonlTail,
-	crashResumeSettleBoundary,
-	pricingRotationUncoveredTail,
-	unknownProviderId,
-	nanStatementRefusal,
-	tokenMismatchDivergence,
-	auditMissingFieldFinding,
-	anthropic1hPriced,
-	pauseTurnUnits,
-	preAdmissionCountRefusal,
-	forcedFinishCompletion,
-	settlementTerminalHonesty,
-	ttlLiveBudgetParity,
-	pauseTurnRealAdapter,
-	statementSettleableGuard,
-	supersededTerminalHonesty,
-	tierCrossingLiveParity,
-	benchmarkPrimaryPreflightParity,
-	benchmarkRecoveryRootExposure,
-	parityQuiescenceDeadlock,
-	paritySequentialRosterFloor,
-	{
-		name: "parity-reserve-line-redemption",
-		doctrine: "a coordination turn refused at the reserve line folds typed 'budget-floor' and the held synthesis reserve funds the redemption whose result rides the partial envelope (RV2101); the PlanRunner extension arm produces the same fold and the same redeemed result (DEF-7)",
-		async run() {
-			const runArm = async (mode) => {
-				const calls = [];
-				const adapter = {
-					id: "fake",
-					calls,
-					caps: scriptedCaps,
-					async *stream(req) {
-						const call = calls.length;
-						calls.push(req);
-						await Promise.resolve();
-						if (scriptedAgentType(req) !== "") {
-							yield {
-								type: "text-delta",
-								text: "settled evidence"
-							};
-							yield {
-								type: "finish",
-								finish: { reason: "stop" },
-								usage: {
-									inputTokens: 10,
-									outputTokens: 5,
-									cacheReadTokens: 0,
-									cacheWriteTokens: 0
-								}
-							};
-							return;
-						}
-						if (!(req.tools ?? []).some((tool) => tool.name === "spawn_agent")) {
-							for (const event of scriptedToolEvents("finish", { result: "the redeemed synthesis" }, `id-${String(call)}-0`)) yield event;
-							yield {
-								type: "finish",
-								finish: { reason: "tool-calls" },
-								usage: {
-									inputTokens: 12,
-									outputTokens: 8,
-									cacheReadTokens: 0,
-									cacheWriteTokens: 0
-								}
-							};
-							return;
-						}
-						const turn = calls.filter((prior) => scriptedAgentType(prior) === "" && (prior.tools ?? []).some((tool) => tool.name === "spawn_agent")).length === 1 ? scriptedToolEvents("spawn_agent", {
-							agentType: "worker",
-							prompt: "gather A"
-						}, `id-${String(call)}-0`).concat(scriptedToolEvents("spawn_agent", {
-							agentType: "worker",
-							prompt: "gather B"
-						}, `id-${String(call)}-1`)) : scriptedToolEvents("finish", { result: "unreachable" }, `id-${String(call)}-0`);
-						for (const event of turn) yield event;
+/**
+* The reserve line and its redemption, in BOTH drive modes (RV2101,
+* DEF-7). The first paid parity runs died bare exactly here: the
+* coordination turn whose spent + held synthesis reserve + proposed
+* crossed the orchestrator cap tore the run down with the reserve
+* intact and unreachable. The fold is now typed 'budget-floor' and the
+* held reserve FUNDS the synthesis the run kept it for; the PlanRunner
+* extension arm must produce the same fold and the same redeemed
+* result, which is the DEF-7 parity this scenario documents.
+*/
+const parityReserveLineRedemption = {
+	name: "parity-reserve-line-redemption",
+	doctrine: "a coordination turn refused at the reserve line folds typed 'budget-floor' and the held synthesis reserve funds the redemption whose result rides the partial envelope (RV2101); the PlanRunner extension arm produces the same fold and the same redeemed result (DEF-7)",
+	async run() {
+		const runArm = async (mode) => {
+			const calls = [];
+			const adapter = {
+				id: "fake",
+				calls,
+				caps: scriptedCaps,
+				async *stream(req) {
+					const call = calls.length;
+					calls.push(req);
+					await Promise.resolve();
+					if (scriptedAgentType(req) !== "") {
+						yield {
+							type: "text-delta",
+							text: "settled evidence"
+						};
 						yield {
 							type: "finish",
-							finish: { reason: "tool-calls" },
+							finish: { reason: "stop" },
 							usage: {
 								inputTokens: 10,
-								outputTokens: 1e3,
+								outputTokens: 5,
 								cacheReadTokens: 0,
 								cacheWriteTokens: 0
 							}
 						};
+						return;
 					}
-				};
-				const store = new InMemoryStore();
-				const engine = createEngine({
-					adapters: [adapter],
-					stores: { journal: store },
-					defaults: {
-						routing: {
-							loop: "fake:model",
-							orchestrate: "fake:model",
-							synthesize: "fake:model"
-						},
-						profiles: { worker: { description: "the cheap gatherer" } }
-					}
-				});
-				const opts = {
-					limits: { maxOutputTokensPerTurn: 1e3 },
-					synthesis: {
-						estCost: .006,
-						limits: { maxOutputTokensPerTurn: 500 }
-					},
-					budget: {
-						capUsd: .03,
-						synthesisReserveUsd: .02,
-						finalizeReserveUsd: 0
-					}
-				};
-				const runId = `fault-reserve-line-${mode}`;
-				const outcome = mode === "workflow" ? await engine.run(makeOrchestratorWorkflow("the reserve line shape", opts), void 0, {
-					runId,
-					budgetUsd: 10
-				}).result : await orchestratePlanned(engine, "the reserve line shape", opts, { runId }).result;
-				const entries = await store.load(runId);
-				const fallback = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finalize_fallback");
-				const settle = entries.some((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
-				const value = outcome.value;
-				return {
-					status: outcome.status,
-					error: outcome.error?.message,
-					forcedFinishFallback: value?.forcedFinishFallback,
-					completion: value?.completion,
-					result: value?.result,
-					fallbackReason: (fallback?.value)?.reason,
-					rootClassCalls: calls.filter((req) => scriptedAgentType(req) === "").length,
-					workerOkTerminals: entries.filter((entry) => entry.kind === "agent" && entry.status === "ok").length,
-					settleRecorded: settle,
-					entries
-				};
-			};
-			const arms = {
-				workflow: await runArm("workflow"),
-				extension: await runArm("extension")
-			};
-			const armMatched = (arm) => arm.status === "exhausted" && arm.forcedFinishFallback === true && arm.completion === "partial" && arm.result === "the redeemed synthesis" && arm.fallbackReason === "budget-floor" && arm.rootClassCalls === 2 && arm.settleRecorded;
-			return {
-				observation: {
-					matched: armMatched(arms.workflow) && armMatched(arms.extension),
-					detail: `workflow arm '${arms.workflow.status}' reason=${String(arms.workflow.fallbackReason)} result=${JSON.stringify(arms.workflow.result)} rootCalls=${String(arms.workflow.rootClassCalls)}; extension arm '${arms.extension.status}' reason=${String(arms.extension.fallbackReason)} result=${JSON.stringify(arms.extension.result)} rootCalls=${String(arms.extension.rootClassCalls)} (DEF-7 parity: both arms fold 'budget-floor' and both redeem the synthesis from the held reserve)`
-				},
-				artifacts: [
-					jsonArtifact("arms.json", {
-						workflow: {
-							...arms.workflow,
-							entries: void 0
-						},
-						extension: {
-							...arms.extension,
-							entries: void 0
-						}
-					}),
-					jsonArtifact("journal-workflow.json", arms.workflow.entries),
-					jsonArtifact("journal-extension.json", arms.extension.entries)
-				]
-			};
-		}
-	},
-	{
-		name: "resume-spawn-famine",
-		doctrine: "a resume re-admits recovered agents without re-counting them against lifetimeSpawnCap (RV2201): the kill-mid-fan-out journal resumes to the finished dossier at the EXACT cap, with no 'lifetime spawn cap' decline journaled and only the unsettled workers re-paid; the c7 resume starved its judge and synthesis on re-counted admissions",
-		async run() {
-			const makeAdapter = () => {
-				const calls = [];
-				return {
-					id: "fake",
-					calls,
-					caps: scriptedCaps,
-					async *stream(req) {
-						const call = calls.length;
-						calls.push(req);
-						await Promise.resolve();
-						if (scriptedAgentType(req) !== "") {
-							yield {
-								type: "text-delta",
-								text: "gathered evidence"
-							};
-							yield {
-								type: "finish",
-								finish: { reason: "stop" },
-								usage: {
-									inputTokens: 10,
-									outputTokens: 5,
-									cacheReadTokens: 0,
-									cacheWriteTokens: 0
-								}
-							};
-							return;
-						}
-						if (!(req.tools ?? []).some((tool) => tool.name === "spawn_agent")) {
-							for (const event of scriptedToolEvents("finish", { result: "the resumed dossier" }, `id-${String(call)}-0`)) yield event;
-							yield {
-								type: "finish",
-								finish: { reason: "tool-calls" },
-								usage: {
-									inputTokens: 12,
-									outputTokens: 8,
-									cacheReadTokens: 0,
-									cacheWriteTokens: 0
-								}
-							};
-							return;
-						}
-						const turn = calls.filter((prior) => scriptedAgentType(prior) === "" && (prior.tools ?? []).some((tool) => tool.name === "spawn_agent")).length === 1 ? scriptedToolEvents("spawn_agent", {
-							agentType: "worker",
-							prompt: "gather A"
-						}, `id-${String(call)}-0`).concat(scriptedToolEvents("spawn_agent", {
-							agentType: "worker",
-							prompt: "gather B"
-						}, `id-${String(call)}-1`), scriptedToolEvents("spawn_agent", {
-							agentType: "worker",
-							prompt: "gather C"
-						}, `id-${String(call)}-2`)) : scriptedToolEvents("finish", { result: "the coordination draft" }, `id-${String(call)}-0`);
-						for (const event of turn) yield event;
+					if (!(req.tools ?? []).some((tool) => tool.name === "spawn_agent")) {
+						for (const event of scriptedToolEvents("finish", { result: "the redeemed synthesis" }, `id-${String(call)}-0`)) yield event;
 						yield {
 							type: "finish",
 							finish: { reason: "tool-calls" },
 							usage: {
-								inputTokens: 10,
-								outputTokens: 5,
+								inputTokens: 12,
+								outputTokens: 8,
 								cacheReadTokens: 0,
 								cacheWriteTokens: 0
 							}
 						};
+						return;
 					}
-				};
+					const turn = calls.filter((prior) => scriptedAgentType(prior) === "" && (prior.tools ?? []).some((tool) => tool.name === "spawn_agent")).length === 1 ? scriptedToolEvents("spawn_agent", {
+						agentType: "worker",
+						prompt: "gather A"
+					}, `id-${String(call)}-0`).concat(scriptedToolEvents("spawn_agent", {
+						agentType: "worker",
+						prompt: "gather B"
+					}, `id-${String(call)}-1`)) : scriptedToolEvents("finish", { result: "unreachable" }, `id-${String(call)}-0`);
+					for (const event of turn) yield event;
+					yield {
+						type: "finish",
+						finish: { reason: "tool-calls" },
+						usage: {
+							inputTokens: 10,
+							outputTokens: 1e3,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0
+						}
+					};
+				}
 			};
-			const LIFETIME_SPAWNS = 5;
-			const wf = makeOrchestratorWorkflow("the resumable fan-out", {
-				synthesis: {
-					estCost: .006,
-					limits: { maxOutputTokensPerTurn: 500 }
-				},
-				budget: { finalizeReserveUsd: 0 }
-			});
-			const makeEngine = (adapter, store) => createEngine({
+			const store = new InMemoryStore();
+			const engine = createEngine({
 				adapters: [adapter],
 				stores: { journal: store },
-				budgetDefaults: { lifetimeSpawnCap: LIFETIME_SPAWNS },
 				defaults: {
 					routing: {
 						loop: "fake:model",
 						orchestrate: "fake:model",
 						synthesize: "fake:model"
 					},
-					profiles: { worker: { description: "the resumable gatherer" } }
+					profiles: { worker: { description: "the cheap gatherer" } }
 				}
 			});
-			const storeA = new InMemoryStore();
-			const seeded = await makeEngine(makeAdapter(), storeA).run(wf, void 0, {
-				runId: "fault-resume-famine",
+			const opts = {
+				limits: { maxOutputTokensPerTurn: 1e3 },
+				synthesis: {
+					estCost: .006,
+					limits: { maxOutputTokensPerTurn: 500 }
+				},
+				budget: {
+					capUsd: .03,
+					synthesisReserveUsd: .02,
+					finalizeReserveUsd: 0
+				}
+			};
+			const runId = `fault-reserve-line-${mode}`;
+			const outcome = mode === "workflow" ? await engine.run(makeOrchestratorWorkflow("the reserve line shape", opts), void 0, {
+				runId,
 				budgetUsd: 10
-			}).result;
-			if (seeded.status !== "ok") throw new Error(`fault kit: the seeding run settled '${seeded.status}' instead of ok`);
-			const entriesA = await storeA.load("fault-resume-famine");
-			const firstWorkerOk = entriesA.findIndex((entry) => entry.kind === "agent" && entry.status === "ok");
-			if (firstWorkerOk < 0) throw new Error("fault kit: the seeding journal carries no worker terminal to cut at");
-			const cut = entriesA.slice(0, firstWorkerOk + 1);
-			const storeB = new InMemoryStore();
-			for (const entry of cut) await storeB.append("fault-resume-famine", entry);
-			const resumeAdapter = makeAdapter();
-			const resumed = await makeEngine(resumeAdapter, storeB).resume("fault-resume-famine", wf).result;
-			const entriesB = await storeB.load("fault-resume-famine");
-			const capDeclines = entriesB.filter((entry) => entry.kind === "decision" && JSON.stringify(entry.value ?? {}).includes("lifetime spawn cap"));
-			const redemptionDeclines = entriesB.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_synthesis_redemption_declined");
-			const liveWorkerCalls = resumeAdapter.calls.filter((req) => scriptedAgentType(req) !== "").length;
-			const distinctAgentScopes = new Set(entriesB.filter((entry) => entry.kind === "agent" && entry.status === "running").map((entry) => `${entry.scope}#${String(entry.key)}`)).size;
+			}).result : await orchestratePlanned(engine, "the reserve line shape", opts, { runId }).result;
+			const entries = await store.load(runId);
+			const fallback = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_finalize_fallback");
+			const settle = entries.some((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
+			const value = outcome.value;
 			return {
-				observation: {
-					matched: resumed.status === "ok" && resumed.value === "the resumed dossier" && capDeclines.length === 0 && redemptionDeclines.length === 0 && liveWorkerCalls === 2 && distinctAgentScopes === LIFETIME_SPAWNS,
-					detail: `resumed '${resumed.status}' result=${JSON.stringify(resumed.value)} at lifetimeSpawnCap ${String(LIFETIME_SPAWNS)} (${String(distinctAgentScopes)} distinct lifetime agent scopes); cap declines journaled=${String(capDeclines.length)}, redemption declines=${String(redemptionDeclines.length)}, live worker calls in the resumed segment=${String(liveWorkerCalls)} (the settled worker replayed free)`
-				},
-				artifacts: [
-					jsonArtifact("journal-cut.json", cut),
-					jsonArtifact("resume-outcome.json", {
-						status: resumed.status,
-						value: resumed.value ?? null,
-						liveWorkerCalls
-					}),
-					jsonArtifact("journal-resumed.json", entriesB)
-				]
+				status: outcome.status,
+				error: outcome.error?.message,
+				forcedFinishFallback: value?.forcedFinishFallback,
+				completion: value?.completion,
+				result: value?.result,
+				fallbackReason: (fallback?.value)?.reason,
+				rootClassCalls: calls.filter((req) => scriptedAgentType(req) === "").length,
+				workerOkTerminals: entries.filter((entry) => entry.kind === "agent" && entry.status === "ok").length,
+				settleRecorded: settle,
+				entries
 			};
-		}
-	},
-	{
-		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",
-		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 arms = {
+			workflow: await runArm("workflow"),
+			extension: await runArm("extension")
+		};
+		const armMatched = (arm) => arm.status === "exhausted" && arm.forcedFinishFallback === true && arm.completion === "partial" && arm.result === "the redeemed synthesis" && arm.fallbackReason === "budget-floor" && arm.rootClassCalls === 2 && arm.settleRecorded;
+		return {
+			observation: {
+				matched: armMatched(arms.workflow) && armMatched(arms.extension),
+				detail: `workflow arm '${arms.workflow.status}' reason=${String(arms.workflow.fallbackReason)} result=${JSON.stringify(arms.workflow.result)} rootCalls=${String(arms.workflow.rootClassCalls)}; extension arm '${arms.extension.status}' reason=${String(arms.extension.fallbackReason)} result=${JSON.stringify(arms.extension.result)} rootCalls=${String(arms.extension.rootClassCalls)} (DEF-7 parity: both arms fold 'budget-floor' and both redeem the synthesis from the held reserve)`
+			},
+			artifacts: [
+				jsonArtifact("arms.json", {
+					workflow: {
+						...arms.workflow,
+						entries: void 0
+					},
+					extension: {
+						...arms.extension,
+						entries: void 0
+					}
+				}),
+				jsonArtifact("journal-workflow.json", arms.workflow.entries),
+				jsonArtifact("journal-extension.json", arms.extension.entries)
+			]
+		};
+	}
+};
+/**
+* The c7 resume famine, closed (RV2201). The kill-mid-fan-out journal
+* of the seventh subscription run resumed to an ACCEPTED acceptance and
+* then starved: recovered agents were re-counted against
+* lifetimeSpawnCap, the judge fell to a typed decline naming the cap,
+* and the synthesis spawn died exhausted with the money reserve intact.
+* The counter now counts a scope a single time across the run's whole
+* life, so the exact-cap resume finishes its dossier.
+*/
+const resumeSpawnFamine = {
+	name: "resume-spawn-famine",
+	doctrine: "a resume re-admits recovered agents without re-counting them against lifetimeSpawnCap (RV2201): the kill-mid-fan-out journal resumes to the finished dossier at the EXACT cap, with no 'lifetime spawn cap' decline journaled and only the unsettled workers re-paid; the c7 resume starved its judge and synthesis on re-counted admissions",
+	async run() {
+		const makeAdapter = () => {
 			const calls = [];
-			let finishAttempts = 0;
-			const adapter = {
+			return {
 				id: "fake",
 				calls,
 				caps: scriptedCaps,
@@ -3413,66 +3279,443 @@ const SCENARIOS = [
 					const call = calls.length;
 					calls.push(req);
 					await Promise.resolve();
-					finishAttempts += 1;
-					const result = finishAttempts === 1 ? TRAP_FINISH : FIXED_FINISH;
-					for (const event of scriptedToolEvents("finish", { result }, `id-${String(call)}-0`)) yield event;
+					if (scriptedAgentType(req) !== "") {
+						yield {
+							type: "text-delta",
+							text: "gathered evidence"
+						};
+						yield {
+							type: "finish",
+							finish: { reason: "stop" },
+							usage: {
+								inputTokens: 10,
+								outputTokens: 5,
+								cacheReadTokens: 0,
+								cacheWriteTokens: 0
+							}
+						};
+						return;
+					}
+					if (!(req.tools ?? []).some((tool) => tool.name === "spawn_agent")) {
+						for (const event of scriptedToolEvents("finish", { result: "the resumed dossier" }, `id-${String(call)}-0`)) yield event;
+						yield {
+							type: "finish",
+							finish: { reason: "tool-calls" },
+							usage: {
+								inputTokens: 12,
+								outputTokens: 8,
+								cacheReadTokens: 0,
+								cacheWriteTokens: 0
+							}
+						};
+						return;
+					}
+					const turn = calls.filter((prior) => scriptedAgentType(prior) === "" && (prior.tools ?? []).some((tool) => tool.name === "spawn_agent")).length === 1 ? scriptedToolEvents("spawn_agent", {
+						agentType: "worker",
+						prompt: "gather A"
+					}, `id-${String(call)}-0`).concat(scriptedToolEvents("spawn_agent", {
+						agentType: "worker",
+						prompt: "gather B"
+					}, `id-${String(call)}-1`), scriptedToolEvents("spawn_agent", {
+						agentType: "worker",
+						prompt: "gather C"
+					}, `id-${String(call)}-2`)) : scriptedToolEvents("finish", { result: "the coordination draft" }, `id-${String(call)}-0`);
+					for (const event of turn) yield event;
 					yield {
 						type: "finish",
 						finish: { reason: "tool-calls" },
 						usage: {
 							inputTokens: 10,
-							outputTokens: 40,
+							outputTokens: 5,
 							cacheReadTokens: 0,
 							cacheWriteTokens: 0
 						}
 					};
 				}
 			};
-			const store = new InMemoryStore();
-			const engine = createEngine({
-				adapters: [adapter],
-				stores: { journal: store },
-				defaults: { routing: {
+		};
+		const LIFETIME_SPAWNS = 5;
+		const wf = makeOrchestratorWorkflow("the resumable fan-out", {
+			synthesis: {
+				estCost: .006,
+				limits: { maxOutputTokensPerTurn: 500 }
+			},
+			budget: { finalizeReserveUsd: 0 }
+		});
+		const makeEngine = (adapter, store) => createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			budgetDefaults: { lifetimeSpawnCap: LIFETIME_SPAWNS },
+			defaults: {
+				routing: {
 					loop: "fake:model",
-					orchestrate: "fake:model"
-				} }
+					orchestrate: "fake:model",
+					synthesize: "fake:model"
+				},
+				profiles: { worker: { description: "the resumable gatherer" } }
+			}
+		});
+		const storeA = new InMemoryStore();
+		const seeded = await makeEngine(makeAdapter(), storeA).run(wf, void 0, {
+			runId: "fault-resume-famine",
+			budgetUsd: 10
+		}).result;
+		if (seeded.status !== "ok") throw new Error(`fault kit: the seeding run settled '${seeded.status}' instead of ok`);
+		const entriesA = await storeA.load("fault-resume-famine");
+		const firstWorkerOk = entriesA.findIndex((entry) => entry.kind === "agent" && entry.status === "ok");
+		if (firstWorkerOk < 0) throw new Error("fault kit: the seeding journal carries no worker terminal to cut at");
+		const cut = entriesA.slice(0, firstWorkerOk + 1);
+		const storeB = new InMemoryStore();
+		for (const entry of cut) await storeB.append("fault-resume-famine", entry);
+		const resumeAdapter = makeAdapter();
+		const resumed = await makeEngine(resumeAdapter, storeB).resume("fault-resume-famine", wf).result;
+		const entriesB = await storeB.load("fault-resume-famine");
+		const capDeclines = entriesB.filter((entry) => entry.kind === "decision" && JSON.stringify(entry.value ?? {}).includes("lifetime spawn cap"));
+		const redemptionDeclines = entriesB.filter((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_synthesis_redemption_declined");
+		const liveWorkerCalls = resumeAdapter.calls.filter((req) => scriptedAgentType(req) !== "").length;
+		const distinctAgentScopes = new Set(entriesB.filter((entry) => entry.kind === "agent" && entry.status === "running").map((entry) => `${entry.scope}#${String(entry.key)}`)).size;
+		return {
+			observation: {
+				matched: resumed.status === "ok" && resumed.value === "the resumed dossier" && capDeclines.length === 0 && redemptionDeclines.length === 0 && liveWorkerCalls === 2 && distinctAgentScopes === LIFETIME_SPAWNS,
+				detail: `resumed '${resumed.status}' result=${JSON.stringify(resumed.value)} at lifetimeSpawnCap ${String(LIFETIME_SPAWNS)} (${String(distinctAgentScopes)} distinct lifetime agent scopes); cap declines journaled=${String(capDeclines.length)}, redemption declines=${String(redemptionDeclines.length)}, live worker calls in the resumed segment=${String(liveWorkerCalls)} (the settled worker replayed free)`
+			},
+			artifacts: [
+				jsonArtifact("journal-cut.json", cut),
+				jsonArtifact("resume-outcome.json", {
+					status: resumed.status,
+					value: resumed.value ?? null,
+					liveWorkerCalls
+				}),
+				jsonArtifact("journal-resumed.json", entriesB)
+			]
+		};
+	}
+};
+/**
+* The c3 validator trap, converging (RV2202). The third subscription
+* run was pinned between two verdicts: evidence-grade demanded a run id
+* 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.
+*/
+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",
+	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 calls = [];
+		let finishAttempts = 0;
+		const adapter = {
+			id: "fake",
+			calls,
+			caps: scriptedCaps,
+			async *stream(req) {
+				const call = calls.length;
+				calls.push(req);
+				await Promise.resolve();
+				finishAttempts += 1;
+				const result = finishAttempts === 1 ? TRAP_FINISH : FIXED_FINISH;
+				for (const event of scriptedToolEvents("finish", { result }, `id-${String(call)}-0`)) yield event;
+				yield {
+					type: "finish",
+					finish: { reason: "tool-calls" },
+					usage: {
+						inputTokens: 10,
+						outputTokens: 40,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0
+					}
+				};
+			}
+		};
+		const store = new InMemoryStore();
+		const engine = createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			defaults: { routing: {
+				loop: "fake:model",
+				orchestrate: "fake:model"
+			} }
+		});
+		const resolveSource = (target) => target.path === "README.md" ? "the rulvar engine\nholds one denominator\nthe engine seals the journal at settle\n" : void 0;
+		const wf = makeOrchestratorWorkflow("the guidance trap", { finishValidation: {
+			validators: [evidenceGradeValidator(), citedValueValidator({
+				resolve: resolveSource,
+				window: 2
+			})],
+			maxRepairs: 2,
+			repairTurnReserve: 2
+		} });
+		const outcome = await engine.run(wf, void 0, {
+			runId: "fault-guidance-conflict",
+			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;
+		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)}`
+			},
+			artifacts: [
+				jsonArtifact("outcome.json", {
+					status: outcome.status,
+					value: outcome.value ?? null
+				}),
+				{
+					name: "repair-request.json",
+					content: repairBytes
+				},
+				jsonArtifact("journal.json", entries)
+			]
+		};
+	}
+};
+const TAIL_POOL_READING = "A failed audit write does not mask success (`src/exec.ts:256-296`).";
+const TAIL_DRAFT_INVERTED = "draft: an audit-write failure does not turn success into failure [src/exec.ts:256-296].";
+const TAIL_FINAL_INVERTED = "final: an audit-write failure does not turn success into failure [src/exec.ts:256-296].";
+const TAIL_FINAL_STILL_INVERTED = "final: the repaired text still flips the recorded outcome [src/exec.ts:256-296].";
+const TAIL_FINAL_CLEAN = "final: a failed audit write does not mask success [src/exec.ts:256-296].";
+const TAIL_FINDS = { contradictions: [{
+	pair: 0,
+	reason: "the draft inverts the recorded reading"
+}] };
+const TAIL_AGREES = { contradictions: [] };
+function tailHandles(req) {
+	const handles = [];
+	for (const msg of req.messages) for (const part of msg.parts) {
+		if (part.type !== "tool-result") continue;
+		const result = part.result;
+		if (typeof result?.handle === "number") handles.push(result.handle);
+		if (Array.isArray(result?.handles)) handles.push(...result.handles.filter((h) => typeof h === "number"));
+	}
+	return handles;
+}
+/**
+* One worker reads the span, the loop finishes with the inverted
+* draft, the composition finishes with `finals` in call order, and the
+* final stage judge answers through `judge` (a structured verdict or a
+* scripted wire death). Label keys ride first so the judge and the
+* composition route exactly, never through the prompt regex.
+*/
+function tailAdapter(options) {
+	let judgeCalls = 0;
+	let synthCalls = 0;
+	let loopTurns = 0;
+	return new FakeAdapter({ agents: {
+		"claim-consistency-judge-final": () => options.judge(judgeCalls += 1),
+		"final-composition": () => fakeToolCalls({
+			name: "finish",
+			args: { result: options.finals[Math.min(synthCalls++, options.finals.length - 1)] }
+		}),
+		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 resolveSource = (target) => target.path === "README.md" ? "the rulvar engine\nholds one denominator\nthe engine seals the journal at settle\n" : void 0;
-			const wf = makeOrchestratorWorkflow("the guidance trap", { finishValidation: {
-				validators: [evidenceGradeValidator(), citedValueValidator({
-					resolve: resolveSource,
-					window: 2
-				})],
-				maxRepairs: 2,
-				repairTurnReserve: 2
-			} });
-			const outcome = await engine.run(wf, void 0, {
-				runId: "fault-guidance-conflict",
+		}
+	} });
+}
+function tailEngine(adapter) {
+	const store = new InMemoryStore();
+	return {
+		engine: createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			defaults: {
+				routing: {
+					loop: FAKE_MODEL_REF,
+					orchestrate: FAKE_MODEL_REF,
+					synthesize: FAKE_MODEL_REF,
+					extract: FAKE_MODEL_REF
+				},
+				profiles: { worker: { description: "reads one span" } }
+			}
+		}),
+		store
+	};
+}
+const TAIL_OPTS = {
+	acceptance: { childPolicy: "all-ok" },
+	synthesis: { limits: { maxTurns: 3 } }
+};
+function tailSpans(entries) {
+	const settled = entries.filter((entry) => entry.kind === "agent" && entry.status !== "running");
+	return {
+		compositions: settled.filter((entry) => entry.costAttribution?.label === "final-composition"),
+		judges: settled.filter((entry) => entry.costAttribution?.label === "claim-consistency-judge-final")
+	};
+}
+const SCENARIOS = [
+	inFlightExposure,
+	duplicateQuotaRule,
+	tornJsonlTail,
+	gluedJsonlTail,
+	crashResumeSettleBoundary,
+	pricingRotationUncoveredTail,
+	unknownProviderId,
+	nanStatementRefusal,
+	tokenMismatchDivergence,
+	auditMissingFieldFinding,
+	anthropic1hPriced,
+	pauseTurnUnits,
+	preAdmissionCountRefusal,
+	forcedFinishCompletion,
+	settlementTerminalHonesty,
+	ttlLiveBudgetParity,
+	pauseTurnRealAdapter,
+	statementSettleableGuard,
+	supersededTerminalHonesty,
+	tierCrossingLiveParity,
+	benchmarkPrimaryPreflightParity,
+	benchmarkRecoveryRootExposure,
+	parityQuiescenceDeadlock,
+	paritySequentialRosterFloor,
+	parityReserveLineRedemption,
+	resumeSpawnFamine,
+	validatorGuidanceConflict,
+	{
+		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 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 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" && 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" && 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
-					}),
-					{
-						name: "repair-request.json",
-						content: repairBytes
-					},
-					jsonArtifact("journal.json", entries)
-				]
+				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: "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)]
 			};
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/evals",
-  "version": "1.238.0",
+  "version": "1.239.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.238.0",
-    "@rulvar/openai": "1.238.0",
-    "@rulvar/core": "1.238.0",
-    "@rulvar/plan": "1.238.0",
-    "@rulvar/testing": "1.238.0"
+    "@rulvar/anthropic": "1.239.0",
+    "@rulvar/core": "1.239.0",
+    "@rulvar/openai": "1.239.0",
+    "@rulvar/testing": "1.239.0",
+    "@rulvar/plan": "1.239.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",