@rulvar/evals 1.225.0 → 1.227.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { ConfigError, InMemoryStore, JsonlFileStore, KnowledgeCasError, LeaseHeldError, SettlementError, SupersededError, claimCoverageOf, claimExpiry, compareRates, compileVerifiedLayer, createEngine, defineWorkflow, hashRunOutput, invoiceFromJournal, journalPricingSnapshot, lastRunSettle, makeOrchestratorWorkflow, memoryQuotaLimiter, pairDraftClaims, pairRunFactClaims, preflightEstimate, priceComponentsOf } from "@rulvar/core";
+import { ConfigError, InMemoryStore, JsonlFileStore, KnowledgeCasError, LeaseHeldError, SettlementError, SupersededError, citedValueValidator, claimCoverageOf, claimExpiry, compareRates, compileVerifiedLayer, createEngine, defineWorkflow, evidenceGradeValidator, hashRunOutput, invoiceFromJournal, journalPricingSnapshot, lastRunSettle, makeOrchestratorWorkflow, memoryQuotaLimiter, pairDraftClaims, pairRunFactClaims, preflightEstimate, priceComponentsOf } from "@rulvar/core";
 import { createHash } from "node:crypto";
 import { appendFileSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -2531,6 +2531,582 @@ const TIER_CROSSING_TURN = {
 		cacheWriteTokens: 0
 	}]
 };
+const tierCrossingLiveParity = {
+	name: "tier-crossing-live-parity",
+	doctrine: "a long-context tier crossed by the sum of one call that no single mid-stream slice reached debits the live budget exactly like the settled fold (RV1101): the per-call marginal meter re-prices the whole call at the crossing slice, live and settled read the same dollars, and a ceiling between the per-slice and tiered readings severs the run instead of settling ok over its own hard cap",
+	async run() {
+		const runTier = async (runId, budgetUsd) => {
+			const handle = createEngine({
+				adapters: [wireAdapter("tier", [TIER_CROSSING_TURN])],
+				stores: { journal: new InMemoryStore() },
+				defaults: { routing: { loop: "tier:model" } },
+				pricing: TIER_PRICING
+			}).run(echoWorkflow, void 0, {
+				runId,
+				budgetUsd
+			});
+			let maxLiveSpentUsd = 0;
+			const ladder = [];
+			handle.on("budget:update", (event) => {
+				if (event.spentUsd > maxLiveSpentUsd) maxLiveSpentUsd = event.spentUsd;
+				if (event.spentUsd > 0 && ladder[ladder.length - 1] !== event.spentUsd) ladder.push(event.spentUsd);
+			});
+			return {
+				outcome: await handle.result,
+				maxLiveSpentUsd,
+				ladder
+			};
+		};
+		const parity = await runTier("fault-tier-parity", 100);
+		const capped = await runTier("fault-tier-capped", 4);
+		const expectedLadder = [
+			1.5,
+			5,
+			5.75
+		];
+		let cursor = 0;
+		for (const reading of parity.ladder) if (reading === expectedLadder[cursor]) cursor += 1;
+		const ladderDriven = cursor === expectedLadder.length;
+		return {
+			observation: {
+				matched: parity.outcome.status === "ok" && parity.outcome.cost.totalUsd === 5.75 && parity.maxLiveSpentUsd === 5.75 && ladderDriven && capped.outcome.status !== "ok" && capped.outcome.cost.totalUsd === 5.75 && capped.maxLiveSpentUsd === capped.outcome.cost.totalUsd,
+				detail: `a 250k call arriving as 150k + 100k slices (no slice crossed the 200k tier) debited live=${String(parity.maxLiveSpentUsd)} USD and settled=${String(parity.outcome.cost.totalUsd)} USD on the same run over the live ladder ${parity.ladder.join(" -> ")}; under the $4 ceiling between the per-slice ($3.00) and tiered readings the run settled '${capped.outcome.status}' at ${String(capped.outcome.cost.totalUsd)} USD with live=${String(capped.maxLiveSpentUsd)}`
+			},
+			artifacts: [jsonArtifact("parity-run.json", {
+				status: parity.outcome.status,
+				settledUsd: parity.outcome.cost.totalUsd,
+				liveUsd: parity.maxLiveSpentUsd,
+				ladder: parity.ladder,
+				usage: parity.outcome.usage
+			}), jsonArtifact("capped-run.json", {
+				status: capped.outcome.status,
+				settledUsd: capped.outcome.cost.totalUsd,
+				liveUsd: capped.maxLiveSpentUsd,
+				ladder: capped.ladder,
+				error: capped.outcome.error?.message ?? null
+			})]
+		};
+	}
+};
+/**
+* RV1905, the four-role benchmark's primary arm as a permanent gate:
+* the exact $6.00 / $4.50 cap / $1.00 synthesis / four 0.62 workers
+* configuration whose preflight read 5/5 green while the live gate
+* refused the third worker. Since RV1901 the projection holds the
+* synthesis reserve like both live gates, seats 2 of 4, exposes the
+* equation terms, and names the roster shortfall as an error finding.
+*/
+const benchmarkPrimaryPreflightParity = {
+	name: "benchmark-primary-preflight-parity",
+	doctrine: "the admission projection holds the synthesis reserve exactly like the live gates (RV1901): the benchmark primary configuration projects 2 of 4 seats with the equation terms exposed and the roster shortfall named admission-below-roster-floor, never the 5/5 green wave the live gate is bound to refuse",
+	run() {
+		const report = preflightEstimate({
+			engine: {
+				adapters: [new FakeAdapter({ agents: { "*": "unused" } })],
+				defaults: { routing: {
+					loop: FAKE_MODEL_REF,
+					orchestrate: FAKE_MODEL_REF,
+					synthesize: FAKE_MODEL_REF
+				} }
+			},
+			run: { budgetUsd: 6 },
+			orchestrator: {
+				budget: {
+					capUsd: 4.5,
+					capFraction: 1,
+					synthesisReserveUsd: 1
+				},
+				synthesis: { limits: { maxTurns: 2 } },
+				acceptance: { minSpawnedChildren: 4 }
+			},
+			spawns: [
+				"product",
+				"finops",
+				"durability",
+				"adversarial"
+			].map((label) => ({
+				label,
+				estCost: .62
+			}))
+		});
+		const denied = report.admission.wave.filter((row) => !row.admitted);
+		const floorFinding = report.findings.find((finding) => finding.code === "admission-below-roster-floor");
+		const matched = report.admission.admitted === 3 && report.admission.denied === 2 && denied.every((row) => row.deniedBy === "budget") && report.admission.synthesisReserveUsd === 1 && Math.abs((report.admission.wave[0]?.reserveUsd ?? 0) - 3.5) < 1e-9 && Math.abs((report.admission.wave[0]?.heldAtEvaluationUsd ?? 0) - 1) < 1e-9 && floorFinding?.severity === "error";
+		return Promise.resolve({
+			observation: {
+				matched,
+				detail: `the wave seats ${String(report.admission.admitted)} of 5 rows (${String(report.admission.denied)} denied by budget), synthesis hold ${String(report.admission.synthesisReserveUsd)} USD, roster finding '${String(floorFinding?.code)}' at severity '${String(floorFinding?.severity)}'`
+			},
+			artifacts: [jsonArtifact("preflight.json", report)]
+		});
+	}
+};
+/**
+* RV1905, the four-role benchmark's recovery arm as a permanent gate:
+* four admitted children still finalizing, the root's next turn refused
+* pre-wire by the exposure cap. Since RV1902 the root parks and
+* retries; since RV1903 every child reaches a journaled terminal before
+* run_settle; since RV1904 the terminal and the invoice share one wire
+* denominator. One scenario drives the whole fixed pipeline.
+*/
+const benchmarkRecoveryRootExposure = {
+	name: "benchmark-recovery-root-exposure",
+	doctrine: "a root turn refused by the in-flight exposure cap beside live children parks and completes after a hold releases (RV1902), every child terminal precedes run_settle (RV1903), and the terminal envelope and the invoice cardinality agree on the wire count (RV1904): the recovery arm terminal-failed on every one of these",
+	async run() {
+		let releaseChildren = () => {};
+		const childrenGate = new Promise((resolve) => {
+			releaseChildren = resolve;
+		});
+		const agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
+		let orchTurn = 0;
+		const calls = [];
+		const toolEvents = (name, args, call) => [
+			{
+				type: "tool-call-start",
+				id: `id-${String(call)}-0`,
+				name
+			},
+			{
+				type: "tool-call-delta",
+				id: `id-${String(call)}-0`,
+				argsTextDelta: JSON.stringify(args)
+			},
+			{
+				type: "tool-call-end",
+				id: `id-${String(call)}-0`,
+				args
+			}
+		];
+		const handlesIn = (req) => {
+			const found = [];
+			for (const msg of req.messages) for (const part of msg.parts) if (part.type === "tool-result") {
+				const result = part.result;
+				if (typeof result.handle === "number") found.push(result.handle);
+			}
+			return found;
+		};
+		const adapter = {
+			id: "fake",
+			calls,
+			caps: () => ({
+				contextWindow: 2e5,
+				maxOutputTokens: 4096,
+				structuredOutput: "native",
+				supportsTemperature: true,
+				supportsParallelTools: true,
+				reasoningEfforts: [],
+				pricing: {
+					inputUsdPerMTok: 1,
+					outputUsdPerMTok: 10
+				}
+			}),
+			async *stream(req, signal) {
+				const call = calls.length;
+				calls.push(req);
+				if (agentTypeOfReq(req) !== "") {
+					await Promise.race([childrenGate, new Promise((resolve) => {
+						signal?.addEventListener("abort", () => resolve(), { once: true });
+					})]);
+					if (signal?.aborted === true) return;
+					yield {
+						type: "text-delta",
+						text: "worked"
+					};
+					yield {
+						type: "finish",
+						finish: { reason: "stop" },
+						usage: {
+							inputTokens: 10,
+							outputTokens: 5,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0
+						}
+					};
+					return;
+				}
+				orchTurn += 1;
+				const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "task A"
+				}, call).concat(toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "task B"
+				}, call + 1e3)) : orchTurn === 2 ? toolEvents("await_all", { handles: handlesIn(req) }, call) : toolEvents("finish", { result: "joined after the wait" }, call);
+				for (const event of turn) yield event;
+				yield {
+					type: "finish",
+					finish: { reason: "tool-calls" },
+					usage: {
+						inputTokens: 10,
+						outputTokens: 5,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0
+					}
+				};
+			}
+		};
+		const store = new InMemoryStore();
+		const engine = createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			defaults: {
+				routing: {
+					loop: "fake:model",
+					orchestrate: "fake:model"
+				},
+				profiles: { worker: {
+					description: "the gated worker",
+					limits: { maxOutputTokensPerTurn: 2500 }
+				} }
+			}
+		});
+		const wf = makeOrchestratorWorkflow("join the gated wave", { limits: { maxOutputTokensPerTurn: 4e3 } });
+		const handle = engine.run(wf, void 0, {
+			runId: "fault-recovery-exposure",
+			budgetUsd: 10,
+			maxInFlightExposureUsd: .08
+		});
+		const waits = [];
+		const errors = [];
+		handle.on("budget:exposure-wait", (event) => {
+			waits.push(event);
+			releaseChildren();
+		});
+		handle.on("agent:error", (event) => errors.push(event));
+		setTimeout(() => releaseChildren(), 4e3).unref?.();
+		const outcome = await handle.result;
+		const entries = await store.load("fault-recovery-exposure");
+		const settle = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
+		const childTerminals = entries.filter((entry) => entry.kind === "agent" && entry.scope.startsWith("agent:") && entry.status !== "running");
+		const invoice = invoiceFromJournal(entries, (servedBy, usage) => {
+			return usage.inputTokens / 1e6 * 1 + usage.outputTokens / 1e6 * 10;
+		});
+		return {
+			observation: {
+				matched: outcome.status === "ok" && outcome.value === "joined after the wait" && waits.length >= 1 && waits[0]?.willWait === true && errors.length === 0 && settle !== void 0 && childTerminals.length === 2 && childTerminals.every((entry) => entry.seq < settle.seq) && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests,
+				detail: `run '${outcome.status}' with ${String(waits.length)} exposure wait(s) (first willWait=${String(waits[0]?.willWait)}), ${String(errors.length)} agent:error, ${String(childTerminals.length)} child terminals before settle seq ${String(settle?.seq)}, 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("events.json", {
+					waits,
+					errors
+				}),
+				jsonArtifact("journal.json", entries)
+			]
+		};
+	}
+};
+/**
+* The third parity rerun's terminal shape as a permanent gate (RV2009):
+* the coordination turn eats most of the exposure cap, every spawned
+* worker is refused DRAINED (typed 'exposure-drained', zero provider
+* attempts, the RV2002 seat instead of the parity mid-research death),
+* the next coordination turn drains too, and the run forced-finishes
+* partial (RV1902) into an exhausted terminal with a sealed journal:
+* run_settle recorded after every agent terminal, the settled fold and
+* the invoice in one denominator (the RV2003 no-silent-exit invariant,
+* where the parity process left a forever-running root and no settle).
+*/
+const parityQuiescenceDeadlock = {
+	name: "parity-quiescence-deadlock",
+	doctrine: "the parity deadlock shape ends in an exhausted terminal, never a silent exit: drained children die typed 'exposure-drained' at zero provider attempts (RV2001/RV2002), the root forced-finishes partial (RV1902), and run_settle seals a one-denominator journal (RV2003); the parity rerun exited mid-run with none of these",
+	async run() {
+		const agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
+		let orchTurn = 0;
+		const calls = [];
+		const toolEvents = (name, args, id) => [
+			{
+				type: "tool-call-start",
+				id,
+				name
+			},
+			{
+				type: "tool-call-delta",
+				id,
+				argsTextDelta: JSON.stringify(args)
+			},
+			{
+				type: "tool-call-end",
+				id,
+				args
+			}
+		];
+		const adapter = {
+			id: "fake",
+			calls,
+			caps: () => ({
+				contextWindow: 2e5,
+				maxOutputTokens: 16e3,
+				structuredOutput: "native",
+				supportsTemperature: true,
+				supportsParallelTools: true,
+				reasoningEfforts: [],
+				pricing: {
+					inputUsdPerMTok: 1,
+					outputUsdPerMTok: 10
+				}
+			}),
+			async *stream(req) {
+				const call = calls.length;
+				calls.push(req);
+				await Promise.resolve();
+				if (agentTypeOfReq(req) !== "") {
+					yield {
+						type: "text-delta",
+						text: "unreachable worker"
+					};
+					yield {
+						type: "finish",
+						finish: { reason: "stop" },
+						usage: {
+							inputTokens: 10,
+							outputTokens: 5,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0
+						}
+					};
+					return;
+				}
+				orchTurn += 1;
+				const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "research A"
+				}, `id-${String(call)}-0`).concat(toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "research B"
+				}, `id-${String(call)}-1`), toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "research C"
+				}, `id-${String(call)}-2`)) : toolEvents("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: orchTurn === 1 ? 2e3 : 5,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0
+					}
+				};
+			}
+		};
+		const store = new InMemoryStore();
+		const engine = createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			defaults: {
+				routing: {
+					loop: "fake:model",
+					orchestrate: "fake:model"
+				},
+				profiles: { worker: {
+					description: "the oversized worker",
+					limits: { maxOutputTokensPerTurn: 1e4 }
+				} }
+			}
+		});
+		const wf = makeOrchestratorWorkflow("the parity shape", { limits: { maxOutputTokensPerTurn: 2500 } });
+		const waits = [];
+		const handle = engine.run(wf, void 0, {
+			runId: "fault-parity-quiescence",
+			budgetUsd: 10,
+			maxInFlightExposureUsd: .04
+		});
+		handle.on("budget:exposure-wait", (event) => waits.push(event));
+		const outcome = await handle.result;
+		const entries = await store.load("fault-parity-quiescence");
+		const drained = entries.filter((entry) => entry.kind === "agent" && entry.status === "error" && (entry.error?.data)?.reason === "exposure-drained");
+		const workerCalls = calls.filter((req) => agentTypeOfReq(req) !== "");
+		const settle = [...entries].reverse().find((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
+		const agentEntries = entries.filter((entry) => entry.kind === "agent");
+		const rosterClosed = agentEntries.filter((entry) => entry.status === "running").map((entry) => entry.seq).every((seq) => agentEntries.some((entry) => entry.ref === seq && entry.status !== "running"));
+		const invoice = invoiceFromJournal(entries, (servedBy, usage) => usage.inputTokens / 1e6 * 1 + usage.outputTokens / 1e6 * 10);
+		const envelope = outcome.value;
+		return {
+			observation: {
+				matched: outcome.status === "exhausted" && envelope?.forcedFinishFallback === true && envelope.completion === "partial" && drained.length === 3 && workerCalls.length === 0 && waits.some((event) => event.scope === "child" && event.willWait === false) && settle !== void 0 && rosterClosed && agentEntries.every((entry) => entry.seq < settle.seq) && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests && invoice.unsettled === void 0,
+				detail: `run '${outcome.status}' (forcedFinishFallback=${String(envelope?.forcedFinishFallback)}, completion=${String(envelope?.completion)}); ${String(drained.length)} drained child terminal(s) at ${String(workerCalls.length)} worker call(s); roster closed=${String(rosterClosed)} before settle seq ${String(settle?.seq)}; wires ${String(outcome.envelope.wireRequests)} == invoice ${String(invoice.cardinality.wireRequests)}, unsettled lane absent=${String(invoice.unsettled === void 0)}`
+			},
+			artifacts: [
+				jsonArtifact("outcome.json", {
+					status: outcome.status,
+					value: outcome.value ?? null,
+					envelope: outcome.envelope
+				}),
+				jsonArtifact("events.json", { waits }),
+				jsonArtifact("journal.json", entries)
+			]
+		};
+	}
+};
+/**
+* The parity roster paid seat by seat under an unreachable floor, as a
+* permanent gate (RV2009): every SINGLE spawn admission projects the
+* whole remaining roster (RV2005) and the FIRST seat refuses typed
+* 'roster_floor' with the arithmetic journaled, zero paid children;
+* the parity arm paid three of four.
+*/
+const paritySequentialRosterFloor = {
+	name: "parity-sequential-roster-floor",
+	doctrine: "a seat-by-seat roster under an unreachable acceptance floor refuses its FIRST seat typed 'roster_floor' with the whole-roster arithmetic journaled and zero paid children (RV2005): the parity arm paid three seats the settle verdict was bound to reject",
+	async run() {
+		const agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
+		let orchTurn = 0;
+		const calls = [];
+		const toolEvents = (name, args, id) => [
+			{
+				type: "tool-call-start",
+				id,
+				name
+			},
+			{
+				type: "tool-call-delta",
+				id,
+				argsTextDelta: JSON.stringify(args)
+			},
+			{
+				type: "tool-call-end",
+				id,
+				args
+			}
+		];
+		const adapter = {
+			id: "fake",
+			calls,
+			caps: () => ({
+				contextWindow: 2e5,
+				maxOutputTokens: 16e3,
+				structuredOutput: "native",
+				supportsTemperature: true,
+				supportsParallelTools: true,
+				reasoningEfforts: [],
+				pricing: {
+					inputUsdPerMTok: 1,
+					outputUsdPerMTok: 10
+				}
+			}),
+			async *stream(req) {
+				const call = calls.length;
+				calls.push(req);
+				await Promise.resolve();
+				if (agentTypeOfReq(req) !== "") {
+					yield {
+						type: "text-delta",
+						text: "seated worker"
+					};
+					yield {
+						type: "finish",
+						finish: { reason: "stop" },
+						usage: {
+							inputTokens: 10,
+							outputTokens: 5,
+							cacheReadTokens: 0,
+							cacheWriteTokens: 0
+						}
+					};
+					return;
+				}
+				orchTurn += 1;
+				const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
+					agentType: "worker",
+					prompt: "seat 1"
+				}, `id-${String(call)}-0`) : toolEvents("finish", { result: "stopped early" }, `id-${String(call)}-0`);
+				for (const event of turn) yield event;
+				yield {
+					type: "finish",
+					finish: { reason: "tool-calls" },
+					usage: {
+						inputTokens: 10,
+						outputTokens: 5,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0
+					}
+				};
+			}
+		};
+		const store = new InMemoryStore();
+		const engine = createEngine({
+			adapters: [adapter],
+			stores: { journal: store },
+			defaults: {
+				routing: {
+					loop: "fake:model",
+					orchestrate: "fake:model"
+				},
+				profiles: { worker: {
+					description: "the estimated worker",
+					estCost: .7
+				} }
+			}
+		});
+		const wf = makeOrchestratorWorkflow("the seat-by-seat parity roster", { acceptance: {
+			childPolicy: "all-ok",
+			minSpawnedChildren: 4
+		} });
+		const rejects = [];
+		const handle = engine.run(wf, void 0, {
+			runId: "fault-parity-roster",
+			budgetUsd: 2.5
+		});
+		handle.on("spawn:rejected", (event) => rejects.push(event));
+		const outcome = await handle.result;
+		const entries = await store.load("fault-parity-roster");
+		const decision = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "spawn-admission" && entry.value.decision?.verdict?.reason?.code === "roster_floor");
+		const reason = (decision?.value)?.decision.verdict.reason;
+		const workerCalls = calls.filter((req) => agentTypeOfReq(req) !== "");
+		return {
+			observation: {
+				matched: workerCalls.length === 0 && rejects.some((event) => event.code === "roster_floor") && decision !== void 0 && reason?.floor === 4 && reason.seatsRemaining === 4 && Math.abs((reason.perSeatProjectionUsd ?? 0) - .7) < 1e-9 && outcome.status === "error",
+				detail: `run '${outcome.status}' with ${String(workerCalls.length)} worker call(s); roster_floor rejected=${String(rejects.some((e) => e.code === "roster_floor"))}, journaled arithmetic floor=${String(reason?.floor)} seatsRemaining=${String(reason?.seatsRemaining)} perSeat=${String(reason?.perSeatProjectionUsd)}`
+			},
+			artifacts: [
+				jsonArtifact("outcome.json", {
+					status: outcome.status,
+					error: outcome.error ?? null
+				}),
+				jsonArtifact("events.json", { rejects }),
+				jsonArtifact("journal.json", entries)
+			]
+		};
+	}
+};
+/** Shared tool-call event triple for scripted orchestrator streams. */
+const scriptedToolEvents = (name, args, id) => [
+	{
+		type: "tool-call-start",
+		id,
+		name
+	},
+	{
+		type: "tool-call-delta",
+		id,
+		argsTextDelta: JSON.stringify(args)
+	},
+	{
+		type: "tool-call-end",
+		id,
+		args
+	}
+];
+const scriptedAgentType = (req) => req.providerOptions?.rulvar?.agentType ?? "";
+const scriptedCaps = () => ({
+	contextWindow: 2e5,
+	maxOutputTokens: 16e3,
+	structuredOutput: "native",
+	supportsTemperature: true,
+	supportsParallelTools: true,
+	reasoningEfforts: [],
+	pricing: {
+		inputUsdPerMTok: 1,
+		outputUsdPerMTok: 10
+	}
+});
 const SCENARIOS = [
 	inFlightExposure,
 	duplicateQuotaRule,
@@ -2551,311 +3127,209 @@ const SCENARIOS = [
 	pauseTurnRealAdapter,
 	statementSettleableGuard,
 	supersededTerminalHonesty,
+	tierCrossingLiveParity,
+	benchmarkPrimaryPreflightParity,
+	benchmarkRecoveryRootExposure,
+	parityQuiescenceDeadlock,
+	paritySequentialRosterFloor,
 	{
-		name: "tier-crossing-live-parity",
-		doctrine: "a long-context tier crossed by the sum of one call that no single mid-stream slice reached debits the live budget exactly like the settled fold (RV1101): the per-call marginal meter re-prices the whole call at the crossing slice, live and settled read the same dollars, and a ceiling between the per-slice and tiered readings severs the run instead of settling ok over its own hard cap",
-		async run() {
-			const runTier = async (runId, budgetUsd) => {
-				const handle = createEngine({
-					adapters: [wireAdapter("tier", [TIER_CROSSING_TURN])],
-					stores: { journal: new InMemoryStore() },
-					defaults: { routing: { loop: "tier:model" } },
-					pricing: TIER_PRICING
-				}).run(echoWorkflow, void 0, {
-					runId,
-					budgetUsd
-				});
-				let maxLiveSpentUsd = 0;
-				const ladder = [];
-				handle.on("budget:update", (event) => {
-					if (event.spentUsd > maxLiveSpentUsd) maxLiveSpentUsd = event.spentUsd;
-					if (event.spentUsd > 0 && ladder[ladder.length - 1] !== event.spentUsd) ladder.push(event.spentUsd);
-				});
-				return {
-					outcome: await handle.result,
-					maxLiveSpentUsd,
-					ladder
-				};
-			};
-			const parity = await runTier("fault-tier-parity", 100);
-			const capped = await runTier("fault-tier-capped", 4);
-			const expectedLadder = [
-				1.5,
-				5,
-				5.75
-			];
-			let cursor = 0;
-			for (const reading of parity.ladder) if (reading === expectedLadder[cursor]) cursor += 1;
-			const ladderDriven = cursor === expectedLadder.length;
-			return {
-				observation: {
-					matched: parity.outcome.status === "ok" && parity.outcome.cost.totalUsd === 5.75 && parity.maxLiveSpentUsd === 5.75 && ladderDriven && capped.outcome.status !== "ok" && capped.outcome.cost.totalUsd === 5.75 && capped.maxLiveSpentUsd === capped.outcome.cost.totalUsd,
-					detail: `a 250k call arriving as 150k + 100k slices (no slice crossed the 200k tier) debited live=${String(parity.maxLiveSpentUsd)} USD and settled=${String(parity.outcome.cost.totalUsd)} USD on the same run over the live ladder ${parity.ladder.join(" -> ")}; under the $4 ceiling between the per-slice ($3.00) and tiered readings the run settled '${capped.outcome.status}' at ${String(capped.outcome.cost.totalUsd)} USD with live=${String(capped.maxLiveSpentUsd)}`
-				},
-				artifacts: [jsonArtifact("parity-run.json", {
-					status: parity.outcome.status,
-					settledUsd: parity.outcome.cost.totalUsd,
-					liveUsd: parity.maxLiveSpentUsd,
-					ladder: parity.ladder,
-					usage: parity.outcome.usage
-				}), jsonArtifact("capped-run.json", {
-					status: capped.outcome.status,
-					settledUsd: capped.outcome.cost.totalUsd,
-					liveUsd: capped.maxLiveSpentUsd,
-					ladder: capped.ladder,
-					error: capped.outcome.error?.message ?? null
-				})]
-			};
-		}
-	},
-	{
-		name: "benchmark-primary-preflight-parity",
-		doctrine: "the admission projection holds the synthesis reserve exactly like the live gates (RV1901): the benchmark primary configuration projects 2 of 4 seats with the equation terms exposed and the roster shortfall named admission-below-roster-floor, never the 5/5 green wave the live gate is bound to refuse",
-		run() {
-			const report = preflightEstimate({
-				engine: {
-					adapters: [new FakeAdapter({ agents: { "*": "unused" } })],
-					defaults: { routing: {
-						loop: FAKE_MODEL_REF,
-						orchestrate: FAKE_MODEL_REF,
-						synthesize: FAKE_MODEL_REF
-					} }
-				},
-				run: { budgetUsd: 6 },
-				orchestrator: {
-					budget: {
-						capUsd: 4.5,
-						capFraction: 1,
-						synthesisReserveUsd: 1
-					},
-					synthesis: { limits: { maxTurns: 2 } },
-					acceptance: { minSpawnedChildren: 4 }
-				},
-				spawns: [
-					"product",
-					"finops",
-					"durability",
-					"adversarial"
-				].map((label) => ({
-					label,
-					estCost: .62
-				}))
-			});
-			const denied = report.admission.wave.filter((row) => !row.admitted);
-			const floorFinding = report.findings.find((finding) => finding.code === "admission-below-roster-floor");
-			const matched = report.admission.admitted === 3 && report.admission.denied === 2 && denied.every((row) => row.deniedBy === "budget") && report.admission.synthesisReserveUsd === 1 && Math.abs((report.admission.wave[0]?.reserveUsd ?? 0) - 3.5) < 1e-9 && Math.abs((report.admission.wave[0]?.heldAtEvaluationUsd ?? 0) - 1) < 1e-9 && floorFinding?.severity === "error";
-			return Promise.resolve({
-				observation: {
-					matched,
-					detail: `the wave seats ${String(report.admission.admitted)} of 5 rows (${String(report.admission.denied)} denied by budget), synthesis hold ${String(report.admission.synthesisReserveUsd)} USD, roster finding '${String(floorFinding?.code)}' at severity '${String(floorFinding?.severity)}'`
-				},
-				artifacts: [jsonArtifact("preflight.json", report)]
-			});
-		}
-	},
-	{
-		name: "benchmark-recovery-root-exposure",
-		doctrine: "a root turn refused by the in-flight exposure cap beside live children parks and completes after a hold releases (RV1902), every child terminal precedes run_settle (RV1903), and the terminal envelope and the invoice cardinality agree on the wire count (RV1904): the recovery arm terminal-failed on every one of these",
+		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() {
-			let releaseChildren = () => {};
-			const childrenGate = new Promise((resolve) => {
-				releaseChildren = resolve;
-			});
-			const agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
-			let orchTurn = 0;
-			const calls = [];
-			const toolEvents = (name, args, call) => [
-				{
-					type: "tool-call-start",
-					id: `id-${String(call)}-0`,
-					name
-				},
-				{
-					type: "tool-call-delta",
-					id: `id-${String(call)}-0`,
-					argsTextDelta: JSON.stringify(args)
-				},
-				{
-					type: "tool-call-end",
-					id: `id-${String(call)}-0`,
-					args
-				}
-			];
-			const handlesIn = (req) => {
-				const found = [];
-				for (const msg of req.messages) for (const part of msg.parts) if (part.type === "tool-result") {
-					const result = part.result;
-					if (typeof result.handle === "number") found.push(result.handle);
-				}
-				return found;
-			};
-			const adapter = {
-				id: "fake",
-				calls,
-				caps: () => ({
-					contextWindow: 2e5,
-					maxOutputTokens: 4096,
-					structuredOutput: "native",
-					supportsTemperature: true,
-					supportsParallelTools: true,
-					reasoningEfforts: [],
-					pricing: {
-						inputUsdPerMTok: 1,
-						outputUsdPerMTok: 10
-					}
-				}),
-				async *stream(req, signal) {
-					const call = calls.length;
-					calls.push(req);
-					if (agentTypeOfReq(req) !== "") {
-						await Promise.race([childrenGate, new Promise((resolve) => {
-							signal?.addEventListener("abort", () => resolve(), { once: true });
-						})]);
-						if (signal?.aborted === true) return;
-						yield {
-							type: "text-delta",
-							text: "worked"
-						};
+			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;
 						yield {
 							type: "finish",
-							finish: { reason: "stop" },
+							finish: { reason: "tool-calls" },
 							usage: {
 								inputTokens: 10,
-								outputTokens: 5,
+								outputTokens: 1e3,
 								cacheReadTokens: 0,
 								cacheWriteTokens: 0
 							}
 						};
-						return;
 					}
-					orchTurn += 1;
-					const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "task A"
-					}, call).concat(toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "task B"
-					}, call + 1e3)) : orchTurn === 2 ? toolEvents("await_all", { handles: handlesIn(req) }, call) : toolEvents("finish", { result: "joined after the wait" }, call);
-					for (const event of turn) yield event;
-					yield {
-						type: "finish",
-						finish: { reason: "tool-calls" },
-						usage: {
-							inputTokens: 10,
-							outputTokens: 5,
-							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 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 }
 					},
-					profiles: { worker: {
-						description: "the gated worker",
-						limits: { maxOutputTokensPerTurn: 2500 }
-					} }
-				}
-			});
-			const wf = makeOrchestratorWorkflow("join the gated wave", { limits: { maxOutputTokensPerTurn: 4e3 } });
-			const handle = engine.run(wf, void 0, {
-				runId: "fault-recovery-exposure",
-				budgetUsd: 10,
-				maxInFlightExposureUsd: .08
-			});
-			const waits = [];
-			const errors = [];
-			handle.on("budget:exposure-wait", (event) => {
-				waits.push(event);
-				releaseChildren();
-			});
-			handle.on("agent:error", (event) => errors.push(event));
-			setTimeout(() => releaseChildren(), 4e3).unref?.();
-			const outcome = await handle.result;
-			const entries = await store.load("fault-recovery-exposure");
-			const settle = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
-			const childTerminals = entries.filter((entry) => entry.kind === "agent" && entry.scope.startsWith("agent:") && entry.status !== "running");
-			const invoice = invoiceFromJournal(entries, (servedBy, usage) => {
-				return usage.inputTokens / 1e6 * 1 + usage.outputTokens / 1e6 * 10;
-			});
+					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: outcome.status === "ok" && outcome.value === "joined after the wait" && waits.length >= 1 && waits[0]?.willWait === true && errors.length === 0 && settle !== void 0 && childTerminals.length === 2 && childTerminals.every((entry) => entry.seq < settle.seq) && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests,
-					detail: `run '${outcome.status}' with ${String(waits.length)} exposure wait(s) (first willWait=${String(waits[0]?.willWait)}), ${String(errors.length)} agent:error, ${String(childTerminals.length)} child terminals before settle seq ${String(settle?.seq)}, wires ${String(outcome.envelope.wireRequests)} == invoice ${String(invoice.cardinality.wireRequests)}`
+					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("outcome.json", {
-						status: outcome.status,
-						value: outcome.value ?? null,
-						envelope: outcome.envelope
-					}),
-					jsonArtifact("events.json", {
-						waits,
-						errors
+					jsonArtifact("arms.json", {
+						workflow: {
+							...arms.workflow,
+							entries: void 0
+						},
+						extension: {
+							...arms.extension,
+							entries: void 0
+						}
 					}),
-					jsonArtifact("journal.json", entries)
+					jsonArtifact("journal-workflow.json", arms.workflow.entries),
+					jsonArtifact("journal-extension.json", arms.extension.entries)
 				]
 			};
 		}
 	},
 	{
-		name: "parity-quiescence-deadlock",
-		doctrine: "the parity deadlock shape ends in an exhausted terminal, never a silent exit: drained children die typed 'exposure-drained' at zero provider attempts (RV2001/RV2002), the root forced-finishes partial (RV1902), and run_settle seals a one-denominator journal (RV2003); the parity rerun exited mid-run with none of these",
+		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 agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
-			let orchTurn = 0;
-			const calls = [];
-			const toolEvents = (name, args, id) => [
-				{
-					type: "tool-call-start",
-					id,
-					name
-				},
-				{
-					type: "tool-call-delta",
-					id,
-					argsTextDelta: JSON.stringify(args)
-				},
-				{
-					type: "tool-call-end",
-					id,
-					args
-				}
-			];
-			const adapter = {
-				id: "fake",
-				calls,
-				caps: () => ({
-					contextWindow: 2e5,
-					maxOutputTokens: 16e3,
-					structuredOutput: "native",
-					supportsTemperature: true,
-					supportsParallelTools: true,
-					reasoningEfforts: [],
-					pricing: {
-						inputUsdPerMTok: 1,
-						outputUsdPerMTok: 10
-					}
-				}),
-				async *stream(req) {
-					const call = calls.length;
-					calls.push(req);
-					await Promise.resolve();
-					if (agentTypeOfReq(req) !== "") {
-						yield {
-							type: "text-delta",
-							text: "unreachable worker"
-						};
+			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;
 						yield {
 							type: "finish",
-							finish: { reason: "stop" },
+							finish: { reason: "tool-calls" },
 							usage: {
 								inputTokens: 10,
 								outputTokens: 5,
@@ -2863,153 +3337,91 @@ const SCENARIOS = [
 								cacheWriteTokens: 0
 							}
 						};
-						return;
 					}
-					orchTurn += 1;
-					const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "research A"
-					}, `id-${String(call)}-0`).concat(toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "research B"
-					}, `id-${String(call)}-1`), toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "research C"
-					}, `id-${String(call)}-2`)) : toolEvents("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: orchTurn === 1 ? 2e3 : 5,
-							cacheReadTokens: 0,
-							cacheWriteTokens: 0
-						}
-					};
-				}
+				};
 			};
-			const store = new InMemoryStore();
-			const engine = createEngine({
+			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 oversized worker",
-						limits: { maxOutputTokensPerTurn: 1e4 }
-					} }
+					profiles: { worker: { description: "the resumable gatherer" } }
 				}
 			});
-			const wf = makeOrchestratorWorkflow("the parity shape", { limits: { maxOutputTokensPerTurn: 2500 } });
-			const waits = [];
-			const handle = engine.run(wf, void 0, {
-				runId: "fault-parity-quiescence",
-				budgetUsd: 10,
-				maxInFlightExposureUsd: .04
-			});
-			handle.on("budget:exposure-wait", (event) => waits.push(event));
-			const outcome = await handle.result;
-			const entries = await store.load("fault-parity-quiescence");
-			const drained = entries.filter((entry) => entry.kind === "agent" && entry.status === "error" && (entry.error?.data)?.reason === "exposure-drained");
-			const workerCalls = calls.filter((req) => agentTypeOfReq(req) !== "");
-			const settle = [...entries].reverse().find((entry) => entry.kind === "decision" && entry.value?.decisionType === "run_settle");
-			const agentEntries = entries.filter((entry) => entry.kind === "agent");
-			const rosterClosed = agentEntries.filter((entry) => entry.status === "running").map((entry) => entry.seq).every((seq) => agentEntries.some((entry) => entry.ref === seq && entry.status !== "running"));
-			const invoice = invoiceFromJournal(entries, (servedBy, usage) => usage.inputTokens / 1e6 * 1 + usage.outputTokens / 1e6 * 10);
-			const envelope = outcome.value;
+			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: outcome.status === "exhausted" && envelope?.forcedFinishFallback === true && envelope.completion === "partial" && drained.length === 3 && workerCalls.length === 0 && waits.some((event) => event.scope === "child" && event.willWait === false) && settle !== void 0 && rosterClosed && agentEntries.every((entry) => entry.seq < settle.seq) && typeof outcome.envelope.wireRequests === "number" && outcome.envelope.wireRequests === invoice.cardinality.wireRequests && invoice.unsettled === void 0,
-					detail: `run '${outcome.status}' (forcedFinishFallback=${String(envelope?.forcedFinishFallback)}, completion=${String(envelope?.completion)}); ${String(drained.length)} drained child terminal(s) at ${String(workerCalls.length)} worker call(s); roster closed=${String(rosterClosed)} before settle seq ${String(settle?.seq)}; wires ${String(outcome.envelope.wireRequests)} == invoice ${String(invoice.cardinality.wireRequests)}, unsettled lane absent=${String(invoice.unsettled === void 0)}`
+					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("outcome.json", {
-						status: outcome.status,
-						value: outcome.value ?? null,
-						envelope: outcome.envelope
+					jsonArtifact("journal-cut.json", cut),
+					jsonArtifact("resume-outcome.json", {
+						status: resumed.status,
+						value: resumed.value ?? null,
+						liveWorkerCalls
 					}),
-					jsonArtifact("events.json", { waits }),
-					jsonArtifact("journal.json", entries)
+					jsonArtifact("journal-resumed.json", entriesB)
 				]
 			};
 		}
 	},
 	{
-		name: "parity-sequential-roster-floor",
-		doctrine: "a seat-by-seat roster under an unreachable acceptance floor refuses its FIRST seat typed 'roster_floor' with the whole-roster arithmetic journaled and zero paid children (RV2005): the parity arm paid three seats the settle verdict was bound to reject",
+		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 agentTypeOfReq = (req) => req.providerOptions?.rulvar?.agentType ?? "";
-			let orchTurn = 0;
+			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 = [];
-			const toolEvents = (name, args, id) => [
-				{
-					type: "tool-call-start",
-					id,
-					name
-				},
-				{
-					type: "tool-call-delta",
-					id,
-					argsTextDelta: JSON.stringify(args)
-				},
-				{
-					type: "tool-call-end",
-					id,
-					args
-				}
-			];
+			let finishAttempts = 0;
 			const adapter = {
 				id: "fake",
 				calls,
-				caps: () => ({
-					contextWindow: 2e5,
-					maxOutputTokens: 16e3,
-					structuredOutput: "native",
-					supportsTemperature: true,
-					supportsParallelTools: true,
-					reasoningEfforts: [],
-					pricing: {
-						inputUsdPerMTok: 1,
-						outputUsdPerMTok: 10
-					}
-				}),
+				caps: scriptedCaps,
 				async *stream(req) {
 					const call = calls.length;
 					calls.push(req);
 					await Promise.resolve();
-					if (agentTypeOfReq(req) !== "") {
-						yield {
-							type: "text-delta",
-							text: "seated worker"
-						};
-						yield {
-							type: "finish",
-							finish: { reason: "stop" },
-							usage: {
-								inputTokens: 10,
-								outputTokens: 5,
-								cacheReadTokens: 0,
-								cacheWriteTokens: 0
-							}
-						};
-						return;
-					}
-					orchTurn += 1;
-					const turn = orchTurn === 1 ? toolEvents("spawn_agent", {
-						agentType: "worker",
-						prompt: "seat 1"
-					}, `id-${String(call)}-0`) : toolEvents("finish", { result: "stopped early" }, `id-${String(call)}-0`);
-					for (const event of turn) yield event;
+					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: 5,
+							outputTokens: 40,
 							cacheReadTokens: 0,
 							cacheWriteTokens: 0
 						}
@@ -3020,43 +3432,45 @@ const SCENARIOS = [
 			const engine = createEngine({
 				adapters: [adapter],
 				stores: { journal: store },
-				defaults: {
-					routing: {
-						loop: "fake:model",
-						orchestrate: "fake:model"
-					},
-					profiles: { worker: {
-						description: "the estimated worker",
-						estCost: .7
-					} }
-				}
+				defaults: { routing: {
+					loop: "fake:model",
+					orchestrate: "fake:model"
+				} }
 			});
-			const wf = makeOrchestratorWorkflow("the seat-by-seat parity roster", { acceptance: {
-				childPolicy: "all-ok",
-				minSpawnedChildren: 4
+			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 rejects = [];
-			const handle = engine.run(wf, void 0, {
-				runId: "fault-parity-roster",
-				budgetUsd: 2.5
-			});
-			handle.on("spawn:rejected", (event) => rejects.push(event));
-			const outcome = await handle.result;
-			const entries = await store.load("fault-parity-roster");
-			const decision = entries.find((entry) => entry.kind === "decision" && entry.value?.decisionType === "spawn-admission" && entry.value.decision?.verdict?.reason?.code === "roster_floor");
-			const reason = (decision?.value)?.decision.verdict.reason;
-			const workerCalls = calls.filter((req) => agentTypeOfReq(req) !== "");
+			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: workerCalls.length === 0 && rejects.some((event) => event.code === "roster_floor") && decision !== void 0 && reason?.floor === 4 && reason.seatsRemaining === 4 && Math.abs((reason.perSeatProjectionUsd ?? 0) - .7) < 1e-9 && outcome.status === "error",
-					detail: `run '${outcome.status}' with ${String(workerCalls.length)} worker call(s); roster_floor rejected=${String(rejects.some((e) => e.code === "roster_floor"))}, journaled arithmetic floor=${String(reason?.floor)} seatsRemaining=${String(reason?.seatsRemaining)} perSeat=${String(reason?.perSeatProjectionUsd)}`
+					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,
-						error: outcome.error ?? null
+						value: outcome.value ?? null
 					}),
-					jsonArtifact("events.json", { rejects }),
+					{
+						name: "repair-request.json",
+						content: repairBytes
+					},
 					jsonArtifact("journal.json", entries)
 				]
 			};