@rulvar/testing 1.0.0

package/dist/index.js

@@ -0,0 +1,1964 @@
+import { CURRENT_HASH_VERSION, ConfigError, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, InMemoryStore, InMemoryTranscriptStore, JournalMissError, Replayer, agentScope, buildDeriverRegistry, canonicalizeSchema, createCanonicalIdMinter, createEngine, defineWorkflow, deriveContentKey, hashWorkflowBody, makeOrchestratorWorkflow, normalizeEntry, projectToJsonSchema, registryKeyRing } from "@rulvar/core";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+//#region src/fake-adapter.ts
+/**
+* FakeAdapter (M1-T14): a REAL ProviderAdapter that resolves calls from
+* declared patterns instead of the network, behind the same seam as live
+* adapters, so unit tests run through the full engine: journal, scheduler,
+* budget layers, and event stream (docs/09, section "Tier 1: FakeAdapter
+* and createTestEngine"). Calls cost zero USD.
+*/
+/** Scripts a tool-calling turn from a responder. */
+function fakeToolCalls(...calls) {
+	return {
+		__fake: "tool-calls",
+		calls
+	};
+}
+/** Scripts a typed wire failure (e.g. a retryable rate limit). */
+function fakeWireError(error) {
+	return {
+		__fake: "wire-error",
+		error
+	};
+}
+function isFakeToolCalls(value) {
+	return typeof value === "object" && value !== null && value.__fake === "tool-calls";
+}
+function isFakeWireError(value) {
+	return typeof value === "object" && value !== null && value.__fake === "wire-error";
+}
+const FAKE_MODEL = "fake-model";
+const FAKE_MODEL_REF = "fake:fake-model";
+const FAKE_CAPS = {
+	structuredOutput: "native",
+	supportsTemperature: true,
+	supportsParallelTools: true,
+	reasoningEfforts: [
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	],
+	contextWindow: 1e6,
+	maxOutputTokens: 64e3,
+	pricing: {
+		inputUsdPerMTok: 0,
+		outputUsdPerMTok: 0
+	}
+};
+function lastUserText(req) {
+	for (let i = req.messages.length - 1; i >= 0; i -= 1) {
+		const msg = req.messages[i];
+		if (msg?.role !== "user") continue;
+		return msg.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+	}
+	return "";
+}
+var FakeAdapter = class {
+	id = "fake";
+	agents;
+	mintId = createCanonicalIdMinter();
+	/** Every request this adapter served, in order. */
+	calls = [];
+	constructor(options) {
+		this.agents = options.agents;
+	}
+	caps() {
+		return FAKE_CAPS;
+	}
+	match(call) {
+		let fallback;
+		for (const [pattern, responder] of Object.entries(this.agents)) {
+			if (pattern === "*") {
+				fallback = responder;
+				continue;
+			}
+			if (call.agentType === pattern || call.label === pattern) return responder;
+			try {
+				if (new RegExp(pattern).test(call.prompt)) return responder;
+			} catch {}
+		}
+		return fallback;
+	}
+	async *stream(req) {
+		const telemetry = req.providerOptions?.rulvar ?? {};
+		const call = {
+			prompt: lastUserText(req),
+			req,
+			...telemetry.agentType === void 0 || telemetry.agentType === "" ? {} : { agentType: telemetry.agentType },
+			...telemetry.label === void 0 ? {} : { label: telemetry.label }
+		};
+		this.calls.push(call);
+		const responder = this.match(call);
+		if (responder === void 0) {
+			yield {
+				type: "error",
+				error: {
+					code: "agent",
+					message: `FakeAdapter: no pattern matches agentType='${call.agentType ?? ""}' label='${call.label ?? ""}' prompt='${call.prompt.slice(0, 80)}'; add a '*' fallback`,
+					retryable: false,
+					data: { kind: "terminal" }
+				}
+			};
+			return;
+		}
+		let value;
+		try {
+			value = typeof responder === "function" ? await responder(call) : responder;
+		} catch (thrown) {
+			yield {
+				type: "error",
+				error: {
+					code: "agent",
+					message: thrown instanceof Error ? thrown.message : String(thrown),
+					retryable: false,
+					data: { kind: "terminal" }
+				}
+			};
+			return;
+		}
+		if (isFakeWireError(value)) {
+			yield {
+				type: "error",
+				error: value.error
+			};
+			return;
+		}
+		if (isFakeToolCalls(value)) {
+			const usage = {
+				inputTokens: Math.max(1, Math.ceil(call.prompt.length / 4)),
+				outputTokens: Math.max(1, value.calls.length * 8),
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0
+			};
+			for (const toolCall of value.calls) {
+				const id = this.mintId();
+				yield {
+					type: "tool-call-start",
+					id,
+					name: toolCall.name
+				};
+				yield {
+					type: "tool-call-end",
+					id,
+					args: toolCall.args
+				};
+			}
+			yield {
+				type: "finish",
+				finish: { reason: "tool-calls" },
+				usage
+			};
+			return;
+		}
+		const text = typeof value === "string" ? value : JSON.stringify(value);
+		const usage = {
+			inputTokens: Math.max(1, Math.ceil(call.prompt.length / 4)),
+			outputTokens: Math.max(1, Math.ceil(text.length / 4)),
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0
+		};
+		const forcedName = typeof req.toolChoice === "object" ? req.toolChoice.name : void 0;
+		if (forcedName !== void 0) {
+			let args = value;
+			if (typeof value === "string") try {
+				args = JSON.parse(value);
+			} catch {
+				args = { text: value };
+			}
+			const id = this.mintId();
+			yield {
+				type: "tool-call-start",
+				id,
+				name: forcedName
+			};
+			yield {
+				type: "tool-call-end",
+				id,
+				args
+			};
+			yield {
+				type: "finish",
+				finish: { reason: "tool-calls" },
+				usage
+			};
+			return;
+		}
+		yield {
+			type: "text-delta",
+			text
+		};
+		yield {
+			type: "finish",
+			finish: { reason: "stop" },
+			usage
+		};
+	}
+};
+//#endregion
+//#region src/test-engine.ts
+/**
+* createTestEngine (M1-T14): a full engine over FakeAdapter with zero
+* network. Orchestration logic is exercised, not mocked around: journal,
+* scheduler, budget layers, and event stream are all real (docs/09,
+* section "Tier 1"). Returned handles record their event stream so the
+* matchers can assert over settled runs.
+*/
+function createTestEngine(options) {
+	const fake = new FakeAdapter({ agents: options.agents });
+	const store = new InMemoryStore();
+	const profiles = { ...options.profiles };
+	for (const key of Object.keys(options.agents)) if (key !== "*" && profiles[key] === void 0) profiles[key] = {};
+	const engine = createEngine({
+		adapters: [fake],
+		stores: { journal: store },
+		defaults: {
+			routing: {
+				loop: FAKE_MODEL_REF,
+				extract: FAKE_MODEL_REF,
+				orchestrate: FAKE_MODEL_REF,
+				plan: FAKE_MODEL_REF,
+				summarize: FAKE_MODEL_REF
+			},
+			profiles
+		},
+		...options.budgetDefaults === void 0 ? {} : { budgetDefaults: options.budgetDefaults },
+		...options.concurrency === void 0 ? {} : { concurrency: options.concurrency }
+	});
+	return {
+		fake,
+		store,
+		stores: engine.stores,
+		resume: (runId, wf, options) => engine.resume(runId, wf, options),
+		deleteRun: (runId) => engine.deleteRun(runId),
+		pruneRun: (runId) => engine.pruneRun(runId),
+		profileCard: (names) => engine.profileCard(names),
+		run(wf, args, opts) {
+			const handle = engine.run(wf, args, opts);
+			const eventsSeen = [];
+			(async () => {
+				for await (const event of handle.events) eventsSeen.push(event);
+			})().catch(() => void 0);
+			return {
+				...handle,
+				eventsSeen
+			};
+		}
+	};
+}
+//#endregion
+//#region src/replay-strict.ts
+/**
+* Tier 3: replay-strict journal runs (M2-T10). Executes a workflow
+* against an existing journal and throws JournalMissError on ANY live
+* call: zero live calls or loud failure. Any production journal becomes a
+* deterministic integration test; a journal with open suspensions
+* completes with outcome 'suspended' and zero live calls (docs/09,
+* section "Tier 3: replay-strict journal runs").
+*/
+const FAKE_ROUTING = {
+	loop: FAKE_MODEL_REF,
+	extract: FAKE_MODEL_REF,
+	orchestrate: FAKE_MODEL_REF,
+	plan: FAKE_MODEL_REF,
+	finalize: FAKE_MODEL_REF,
+	summarize: FAKE_MODEL_REF
+};
+async function replayRun(wf, args, options) {
+	let store;
+	let runId;
+	if (Array.isArray(options.journal)) {
+		runId = options.journal[0] !== void 0 ? "replay-run" : "replay-empty";
+		const memory = new InMemoryStore();
+		for (const entry of options.journal) await memory.append(runId, entry);
+		await memory.putMeta({
+			runId,
+			status: "suspended",
+			updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+			workflowName: wf.name,
+			workflowHash: hashWorkflowBody(wf)
+		});
+		store = memory;
+	} else {
+		store = options.journal.store;
+		runId = options.journal.runId;
+	}
+	const handle = createEngine({
+		adapters: options.adapters ?? [new FakeAdapter({ agents: {} })],
+		stores: { journal: store },
+		defaults: {
+			routing: options.routing ?? FAKE_ROUTING,
+			...options.profiles === void 0 ? {} : { profiles: options.profiles }
+		},
+		...options.onEscalation === void 0 ? {} : { onEscalation: options.onEscalation }
+	}).resume(runId, wf, {
+		args,
+		dryRun: true
+	});
+	const outcome = await handle.result;
+	if (outcome.error?.code === "journal_miss") throw new JournalMissError(outcome.error.message, { data: outcome.error.data ?? null });
+	return {
+		outcome,
+		preview: await handle.preview
+	};
+}
+//#endregion
+//#region src/cassettes/build-fixtures.ts
+/**
+* M2 cassette and frozen-fixture builders (M2-T12). Fixtures are
+* hand-authored journals with REAL content keys (derived through the
+* frozen KeyDeriver profiles), deterministic timestamps, and fixed span
+* ids, so regeneration is byte-stable.
+*
+* The COMMITTED files under repo cassettes/ and
+* packages/testing/fixtures/frozen/ are the contract; these builders
+* exist to regenerate them DELIBERATELY (scripts/record-m2-cassettes.mjs)
+* and to fail loudly in CI when key derivation drifts (docs/11, section
+* "Frozen journal fixtures": regenerating fixtures to make a test pass is
+* forbidden by policy; any diff requires an explicit hashVersion-bump
+* changeset).
+*/
+const BASE_MS$1 = Date.parse("2026-02-01T00:00:00.000Z");
+const SPAN$1 = "fixture-span";
+function stampOf$1(seq) {
+	return new Date(BASE_MS$1 + seq * 1e3).toISOString();
+}
+function usageOf(inputTokens, outputTokens) {
+	return {
+		inputTokens,
+		outputTokens,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	};
+}
+/** The identity ctx.agent computes for a plain prompt against the fake model. */
+function fakeAgentIdentity(prompt, effort) {
+	return {
+		kind: "agent",
+		agentType: "",
+		modelSpec: effort === void 0 ? {
+			kind: "model",
+			model: FAKE_MODEL_REF
+		} : {
+			kind: "model",
+			model: FAKE_MODEL_REF,
+			effort
+		},
+		prompt,
+		schemaHash: EMPTY_SCHEMA_HASH,
+		toolsetHash: EMPTY_TOOLSET_HASH,
+		isolation: "none"
+	};
+}
+const RING = registryKeyRing(buildDeriverRegistry());
+/**
+* Derives the content key an entry of `hashVersion` carries for this
+* identity. The synthetic hashVersion 0 profile of @rulvar/compat shares
+* the v1 projection by construction (deriverV0Synthetic =
+* { ...deriverV1, hashVersion: 0 }), so v0 fixture keys derive through
+* the v1 profile; synthetic FUTURE versions borrow the v2 derivation (the
+* compatibility scan rejects them before any key is ever compared).
+*/
+function keyFor(identity, hashVersion) {
+	const effective = hashVersion === 0 ? 1 : hashVersion > 2 ? 2 : hashVersion;
+	const derived = RING.keyFor(identity, effective);
+	if (derived === "incomparable") throw new Error(`fixture identity is incomparable under hashVersion ${String(hashVersion)}`);
+	return derived.key;
+}
+/** Deterministic journal author: seq, stamps, and ordinals are derived. */
+var FixtureJournal = class {
+	entries = [];
+	seq = 0;
+	ordinals = /* @__PURE__ */ new Map();
+	mint(partial) {
+		const seq = this.seq;
+		this.seq += 1;
+		const ordinalKey = `${partial.scope} ${partial.hashVersion} ${partial.key}`;
+		const ordinal = partial.ref === void 0 && partial.kind !== "resolution" && partial.kind !== "abandon" ? this.ordinals.get(ordinalKey) ?? 0 : 0;
+		if (partial.ref === void 0 && partial.kind !== "resolution" && partial.kind !== "abandon") this.ordinals.set(ordinalKey, ordinal + 1);
+		const entry = {
+			...partial,
+			seq,
+			ordinal,
+			spanId: SPAN$1,
+			startedAt: stampOf$1(seq)
+		};
+		this.entries.push(entry);
+		return entry;
+	}
+	/** Two-phase agent operation: running plus terminal. Returns the running entry. */
+	agentOp(input) {
+		const hashVersion = input.hashVersion ?? 2;
+		const identity = fakeAgentIdentity(input.prompt, input.effort);
+		const running = this.mint({
+			hashVersion,
+			scope: input.scope ?? "",
+			key: keyFor(identity, hashVersion),
+			kind: "agent",
+			status: "running",
+			...input.memoizeOutcome === void 0 ? {} : { memoizeOutcome: input.memoizeOutcome }
+		});
+		const terminal = this.mint({
+			hashVersion,
+			ref: running.seq,
+			scope: running.scope,
+			key: running.key,
+			kind: "agent",
+			status: input.status ?? "ok",
+			...input.value === void 0 ? {} : { value: input.value },
+			...input.error === void 0 ? {} : { error: input.error },
+			...input.usage === void 0 ? {} : { usage: input.usage },
+			servedBy: FAKE_MODEL_REF,
+			endedAt: stampOf$1(this.seq)
+		});
+		terminal.ordinal = running.ordinal;
+		return running;
+	}
+	/** A hanging two-phase dispatch (crash before the terminal). */
+	danglingAgent(input) {
+		const hashVersion = input.hashVersion ?? 2;
+		const identity = fakeAgentIdentity(input.prompt);
+		return this.mint({
+			hashVersion,
+			scope: input.scope ?? "",
+			key: keyFor(identity, hashVersion),
+			kind: "agent",
+			status: "running"
+		});
+	}
+	stepOp(input) {
+		const hashVersion = input.hashVersion ?? 2;
+		const identity = {
+			kind: "step",
+			key: input.label,
+			deps: []
+		};
+		const running = this.mint({
+			hashVersion,
+			scope: "",
+			key: keyFor(identity, hashVersion),
+			kind: "step",
+			status: "running"
+		});
+		const terminal = this.mint({
+			hashVersion,
+			ref: running.seq,
+			scope: "",
+			key: running.key,
+			kind: "step",
+			status: "ok",
+			value: input.value,
+			endedAt: stampOf$1(this.seq)
+		});
+		terminal.ordinal = running.ordinal;
+		return running;
+	}
+	randNow(value, hashVersion = 2) {
+		return this.mint({
+			hashVersion,
+			scope: "",
+			key: keyFor({
+				kind: "rand",
+				subtype: "now"
+			}, hashVersion),
+			kind: "rand",
+			status: "ok",
+			value: {
+				subtype: "now",
+				value
+			},
+			endedAt: stampOf$1(this.seq)
+		});
+	}
+	external(input) {
+		const hashVersion = input.hashVersion ?? 2;
+		const identity = {
+			kind: "external",
+			key: input.key
+		};
+		const payload = { key: input.key };
+		if (input.prompt !== void 0) payload.prompt = input.prompt;
+		if (input.schema !== void 0) payload.schema = canonicalizeSchema(projectToJsonSchema(input.schema));
+		return this.mint({
+			hashVersion,
+			scope: input.scope ?? "",
+			key: keyFor(identity, hashVersion),
+			kind: "external",
+			status: "suspended",
+			value: payload
+		});
+	}
+	approvalSuspended(input) {
+		const hashVersion = input.hashVersion ?? 2;
+		const identity = {
+			kind: "approval",
+			toolName: input.toolName,
+			input: input.toolInput
+		};
+		return this.mint({
+			hashVersion,
+			scope: "",
+			key: keyFor(identity, hashVersion),
+			kind: "approval",
+			status: "suspended",
+			value: {
+				toolName: input.toolName,
+				input: input.toolInput
+			}
+		});
+	}
+	resolution(input) {
+		const target = this.entries.find((entry) => entry.seq === input.target);
+		return this.mint({
+			hashVersion: 2,
+			ref: input.target,
+			scope: target?.scope ?? "",
+			key: "",
+			kind: "resolution",
+			status: "ok",
+			resolution: {
+				target: input.target,
+				by: input.by,
+				value: input.value,
+				...input.decisionRef === void 0 ? {} : { decisionRef: input.decisionRef }
+			}
+		});
+	}
+	abandon(input) {
+		const target = this.entries.find((entry) => entry.seq === input.target);
+		const payload = {
+			target: input.target,
+			authorizedBy: input.authorizedBy,
+			reason: input.reason,
+			retainCheckpoint: true,
+			retainWorktree: false
+		};
+		return this.mint({
+			hashVersion: 2,
+			ref: input.target,
+			scope: target?.scope ?? "",
+			key: "",
+			kind: "abandon",
+			status: "ok",
+			abandon: payload
+		});
+	}
+	decision(input) {
+		return this.mint({
+			hashVersion: 2,
+			scope: "",
+			key: deriveContentKey({
+				kind: "step",
+				key: `decision:${input.decisionType}`,
+				deps: []
+			}),
+			kind: "decision",
+			status: "ok",
+			value: {
+				decisionType: input.decisionType,
+				...input.payload
+			},
+			endedAt: stampOf$1(this.seq)
+		});
+	}
+};
+/** Shared schemas (canonical projections are pinned inside the fixtures). */
+const APPROVED_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["approved"],
+	properties: { approved: { type: "boolean" } }
+};
+const DECISION_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["decision"],
+	properties: { decision: { type: "string" } }
+};
+const GO_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["go"],
+	properties: { go: { type: "boolean" } }
+};
+/** Prompts shared between fixture entries and cassette workflow bodies. */
+const PROMPTS = {
+	branchWork: "branch work",
+	childOk: "child ok",
+	childEscalated: "child escalated",
+	childHanging: "child hanging",
+	classify: "classify the document",
+	summarize: "summarize the document",
+	alpha: "alpha stage",
+	beta: "beta stage",
+	gamma: "gamma stage",
+	analyze: "analyze the incident",
+	reviseReport: "revise the report",
+	childResearch: "child research",
+	childDraft: "child draft",
+	revisionEffects: "apply the revision effects",
+	branchAlpha: "branch alpha",
+	subtreeAlpha: "subtree alpha",
+	innerAlpha: "inner alpha work",
+	v0Relic: "v0 relic stage",
+	futureStage: "future stage",
+	draftSummary: "draft the summary",
+	polishIntro: "polish the intro",
+	sharedStage: "shared stage",
+	crossCheck: "cross-check the citations",
+	assessTone: "assess the tone"
+};
+function buildM2CassetteFixtures() {
+	const fixtures = [];
+	{
+		const j = new FixtureJournal();
+		j.agentOp({
+			prompt: PROMPTS.alpha,
+			hashVersion: 1,
+			value: "alpha out",
+			usage: usageOf(100, 10)
+		});
+		j.agentOp({
+			prompt: PROMPTS.beta,
+			hashVersion: 1,
+			status: "error",
+			error: {
+				code: "agent",
+				message: "upstream disconnected",
+				retryable: true,
+				data: { kind: "transport" }
+			},
+			usage: usageOf(10, 0)
+		});
+		j.agentOp({
+			prompt: PROMPTS.gamma,
+			hashVersion: 1,
+			status: "cancelled",
+			usage: usageOf(5, 0)
+		});
+		fixtures.push({
+			id: "v1-journal-on-v2",
+			note: "DEF-1: a journal without the new statuses and kinds resumes on the v2 engine; ok replays, error and cancelled rerun, byte-identical to the round-1 table.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		j.agentOp({
+			prompt: PROMPTS.analyze,
+			value: "analysis: rollback recommended",
+			usage: usageOf(120, 30)
+		});
+		const gate = j.external({
+			key: "escalation-report",
+			schema: DECISION_SCHEMA,
+			prompt: "Escalation decision required"
+		});
+		j.resolution({
+			target: gate.seq,
+			by: "external",
+			value: { decision: "rollback" }
+		});
+		j.resolution({
+			target: gate.seq,
+			by: "timeout",
+			value: { decision: "proceed-default" }
+		});
+		fixtures.push({
+			id: "timeout-vs-live-race",
+			note: "DEF-4: the live decision wins in journal order; the timeout attempt lands as a journaled noop whose effects are never re-issued.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		const r1 = j.external({ key: "report-1" });
+		const r2 = j.external({ key: "report-2" });
+		const r3 = j.external({ key: "report-3" });
+		j.resolution({
+			target: r2.seq,
+			by: "operator",
+			value: { action: "retry" }
+		});
+		const dec = j.decision({
+			decisionType: "escalation-class",
+			payload: {
+				action: "retry",
+				appliesTo: [
+					r1.seq,
+					r2.seq,
+					r3.seq
+				]
+			}
+		});
+		j.resolution({
+			target: r1.seq,
+			by: "class_decision",
+			decisionRef: dec.seq,
+			value: { action: "retry" }
+		});
+		j.resolution({
+			target: r2.seq,
+			by: "class_decision",
+			decisionRef: dec.seq,
+			value: { action: "retry" }
+		});
+		j.resolution({
+			target: r3.seq,
+			by: "class_decision",
+			decisionRef: dec.seq,
+			value: { action: "retry" }
+		});
+		fixtures.push({
+			id: "class-decision-fanout",
+			note: "DEF-4: a class-level decision closes three suspended reports, one already closed individually: two applied, one noop with decisionRef preserved. The decision fact itself gains a live consumer in M4.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		const spawn = j.danglingAgent({ prompt: PROMPTS.reviseReport });
+		const subtree = agentScope("", spawn.seq);
+		j.agentOp({
+			prompt: PROMPTS.childResearch,
+			scope: subtree,
+			value: "notes",
+			usage: usageOf(80, 15)
+		});
+		j.agentOp({
+			prompt: PROMPTS.childDraft,
+			scope: subtree,
+			value: "draft",
+			usage: usageOf(90, 25)
+		});
+		j.abandon({
+			target: spawn.seq,
+			authorizedBy: spawn.seq,
+			reason: "plan revision: cancel_task"
+		});
+		fixtures.push({
+			id: "abandon-then-crash-then-resume",
+			note: "DEF-4: crash strictly after the abandon and before any effects; resume derives skipped for the whole subtree (skipped, never orphaned) and re-issues only the revision effects.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		const spawnA = j.danglingAgent({ prompt: PROMPTS.branchAlpha });
+		const suspA = j.external({
+			key: "alpha-gate",
+			scope: agentScope("", spawnA.seq)
+		});
+		j.abandon({
+			target: spawnA.seq,
+			authorizedBy: spawnA.seq,
+			reason: "cancelled"
+		});
+		j.resolution({
+			target: suspA.seq,
+			by: "external",
+			value: { go: true }
+		});
+		const suspB = j.external({
+			key: "beta-gate",
+			schema: GO_SCHEMA
+		});
+		j.resolution({
+			target: suspB.seq,
+			by: "external",
+			value: { go: true }
+		});
+		j.abandon({
+			target: suspB.seq,
+			authorizedBy: spawnA.seq,
+			reason: "late cancel"
+		});
+		fixtures.push({
+			id: "abandon-vs-resolution-race",
+			note: "DEF-4: a resolution after a covering abandon is a noop (target_abandoned); the reverse order yields an applied resolution and a noop abandon (already_resolved).",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		const gate = j.external({
+			key: "deploy-approval",
+			schema: APPROVED_SCHEMA,
+			prompt: "Approve the deployment?"
+		});
+		j.resolution({
+			target: gate.seq,
+			by: "external",
+			value: { approved: "yes" }
+		});
+		j.resolution({
+			target: gate.seq,
+			by: "operator",
+			value: { approved: true }
+		});
+		fixtures.push({
+			id: "offline-invalid-then-valid",
+			note: "DEF-4: the schema-invalid offline resolution classifies invalid and never closes; the valid one applies; resume consumes the valid value deterministically.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		const spawn = j.agentOp({
+			prompt: PROMPTS.subtreeAlpha,
+			value: "alpha done",
+			usage: usageOf(150, 30)
+		});
+		const inner = j.agentOp({
+			prompt: PROMPTS.innerAlpha,
+			scope: agentScope("", spawn.seq),
+			value: "inner out",
+			usage: usageOf(70, 10)
+		});
+		j.abandon({
+			target: spawn.seq,
+			authorizedBy: spawn.seq,
+			reason: "first revision"
+		});
+		j.abandon({
+			target: inner.seq,
+			authorizedBy: spawn.seq,
+			reason: "second revision overlaps"
+		});
+		fixtures.push({
+			id: "double-abandon-idempotent",
+			note: "DEF-4: the second abandon over an already-covered target folds to noop; abandon beats the terminal ok status; live and replayed states identical, no repayment.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		j.agentOp({
+			prompt: PROMPTS.v0Relic,
+			hashVersion: 0,
+			value: "relic out",
+			usage: usageOf(40, 5)
+		});
+		fixtures.push({
+			id: "reject-version-too-old",
+			note: "DEF-6: hashVersion 0 sits outside the [1,2] window: JournalCompatibilityError HASH_VERSION_TOO_OLD with zero side effects; deriverV0Synthetic from @rulvar/compat reopens the window via extraDerivers.",
+			entries: j.entries
+		});
+	}
+	{
+		const j = new FixtureJournal();
+		j.agentOp({
+			prompt: PROMPTS.futureStage,
+			hashVersion: 3,
+			value: "future out",
+			usage: usageOf(40, 5)
+		});
+		fixtures.push({
+			id: "reject-version-from-future",
+			note: "DEF-6: a hashVersion 3 entry on the v2 engine: HASH_VERSION_TOO_NEW at load with zero side effects; the lease-acquire repetition of the scan re-records with queue mode in M5.",
+			entries: j.entries
+		});
+	}
+	return fixtures;
+}
+/**
+* The frozen v1 journal (docs/11, section "Frozen journal fixtures"): a
+* round-1 JSONL file with kinds agent, step, rand, external, approval and
+* the legacy `v: 1` field (no hashVersion member). Returned as raw
+* JSON-ready objects, one per line.
+*/
+function buildFrozenV1JournalRaw() {
+	const j = new FixtureJournal();
+	j.agentOp({
+		prompt: PROMPTS.draftSummary,
+		hashVersion: 1,
+		value: "summary text, first draft",
+		usage: usageOf(220, 80)
+	});
+	j.stepOp({
+		label: "persist-draft",
+		value: {
+			written: true,
+			path: "drafts/summary.md"
+		},
+		hashVersion: 1
+	});
+	j.randNow(17067456e5, 1);
+	j.external({
+		key: "editor-approval",
+		schema: APPROVED_SCHEMA,
+		prompt: "Approve the draft?",
+		hashVersion: 1
+	});
+	j.approvalSuspended({
+		toolName: "publish",
+		toolInput: { channel: "blog" },
+		hashVersion: 1
+	});
+	j.agentOp({
+		prompt: PROMPTS.polishIntro,
+		hashVersion: 1,
+		value: "intro pass one",
+		usage: usageOf(60, 12)
+	});
+	j.agentOp({
+		prompt: PROMPTS.polishIntro,
+		hashVersion: 1,
+		value: "intro pass two",
+		usage: usageOf(61, 13)
+	});
+	return j.entries.map((entry) => {
+		const { hashVersion: _hashVersion, ...rest } = entry;
+		return {
+			v: 1,
+			...rest
+		};
+	});
+}
+/** The docs/03 section 1.5 worked example, frozen as executable data. */
+const WORKED_EXAMPLE_INPUT = {
+	kind: "agent",
+	agentType: "reviewer",
+	modelSpec: {
+		kind: "model",
+		model: "anthropic:claude-sonnet-4",
+		effort: "high"
+	},
+	prompt: "Review the attached diff for correctness.",
+	schemaHash: "f1342f68c9dbb49e8056d0414479659414776dfa4c599b3bebd166c8fdc416ba",
+	toolsetHash: "d2c59d7e8cb64de34366877e8764eab84d615942f14167d8715a15d8dbff105c",
+	isolation: "none"
+};
+/**
+* v2 golden identity fixtures: worked examples per spawn kind (M2-T12).
+* The keys freeze the hashVersion 2 profile; the v1 members freeze the
+* effort-insensitive projection and the incomparable domain.
+*/
+function buildV2GoldenIdentity() {
+	return {
+		note: "FROZEN v2 identity contract (DEF-6). Any diff requires a hashVersion-bump changeset.",
+		workedExampleKey: "66ef15922e576a8f6884b28176c8c21fee9b4d3bb98c76592ed6ca1d3c8f1062",
+		emptySchemaHash: EMPTY_SCHEMA_HASH,
+		emptyToolsetHash: EMPTY_TOOLSET_HASH,
+		perKind: [
+			{
+				name: "agent (docs/03 1.5 worked example)",
+				input: WORKED_EXAMPLE_INPUT
+			},
+			{
+				name: "agent (fake model, no effort)",
+				input: fakeAgentIdentity(PROMPTS.draftSummary)
+			},
+			{
+				name: "child",
+				input: {
+					kind: "child",
+					workflow: "sub-flow",
+					args: { topic: "rulvar" }
+				}
+			},
+			{
+				name: "step",
+				input: {
+					kind: "step",
+					key: "persist-draft",
+					deps: []
+				}
+			},
+			{
+				name: "step (deps)",
+				input: {
+					kind: "step",
+					key: "fetch",
+					deps: [{ page: 2 }]
+				}
+			},
+			{
+				name: "external",
+				input: {
+					kind: "external",
+					key: "editor-approval"
+				}
+			},
+			{
+				name: "approval",
+				input: {
+					kind: "approval",
+					toolName: "publish",
+					input: { channel: "blog" }
+				}
+			},
+			{
+				name: "rand now",
+				input: {
+					kind: "rand",
+					subtype: "now"
+				}
+			},
+			{
+				name: "rand keyed",
+				input: {
+					kind: "rand",
+					subtype: "random",
+					key: "jitter"
+				}
+			}
+		].map((example) => ({
+			name: example.name,
+			input: example.input,
+			key: deriveContentKey(example.input)
+		})),
+		v1: {
+			agentEffortInsensitive: {
+				withEffort: keyFor(fakeAgentIdentity(PROMPTS.draftSummary, "high"), 1),
+				withoutEffort: keyFor(fakeAgentIdentity(PROMPTS.draftSummary), 1)
+			},
+			incomparableKinds: [
+				"decision",
+				"plan.revision",
+				"plan.decision",
+				"ledger.op",
+				"node.link",
+				"termination.init",
+				"termination.denied"
+			]
+		}
+	};
+}
+//#endregion
+//#region src/cassettes/record-live.ts
+/**
+* Live-recorded cassettes (M3-T11): the DEF-1 live set (escalate-replay,
+* crash-between-report-and-decision, flavor-b-timeout) plus the
+* re-recorded M2 synthetic DEF-1 subset (abandon-subtree,
+* memoize-classifier), produced through the REAL runtime: engine runs
+* over FakeAdapter for everything with a live producer, kernel write
+* APIs (Replayer) for the orchestrator-subtree shape whose spawning
+* producer arrives with mode (c) in M6/M7. Timestamps and span ids are
+* normalized deterministically after recording (matching never reads
+* them); regeneration is DELIBERATE per the frozen-fixture policy
+* (docs/11).
+*/
+const BASE_MS = Date.parse("2026-02-01T00:00:00.000Z");
+const SPAN = "fixture-span";
+function stampOf(seq) {
+	return new Date(BASE_MS + seq * 1e3).toISOString();
+}
+/**
+* Wall-clock and span normalization: matching consumes neither, and
+* frozen bytes must not depend on the recording machine.
+*/
+function normalizeEntries(entries) {
+	return entries.map((entry) => ({
+		...entry,
+		spanId: SPAN,
+		startedAt: stampOf(entry.seq),
+		...entry.endedAt === void 0 ? {} : { endedAt: stampOf(entry.seq) },
+		...entry.deadlineAt === void 0 ? {} : { deadlineAt: new Date(BASE_MS + entry.seq * 1e3 + 6e4).toISOString() }
+	}));
+}
+/** The deterministic escalate request every recording uses. */
+const RECORDED_ESCALATE_ARGS = {
+	kind: "scope_bigger",
+	scopeDelta: "the billing migration spans nine services, not one",
+	revisedEstimate: {
+		usd: 40,
+		turns: 90
+	},
+	blockers: ["schema ownership is unclear"]
+};
+const ESCALATE_REPLAY_PROMPTS = {
+	work: "migrate the billing system",
+	retry: "retry: split the billing migration by service"
+};
+/** The workflow of the escalate-replay cassette; tests import it. */
+function escalateReplayWorkflow() {
+	return defineWorkflow({ name: "escalate-replay" }, async (ctx) => {
+		try {
+			await ctx.agent(ESCALATE_REPLAY_PROMPTS.work, { escalation: {} });
+			return "no escalation";
+		} catch {
+			return await ctx.agent(ESCALATE_REPLAY_PROMPTS.retry);
+		}
+	});
+}
+const CRASH_BETWEEN_PROMPT = "stabilize the flaky import pipeline";
+/** Phase 1 (recorded): the report lands, the process dies before any decision. */
+function crashBetweenPhase1Workflow() {
+	return defineWorkflow({ name: "crash-between-report-and-decision" }, async (ctx) => {
+		await ctx.agent(CRASH_BETWEEN_PROMPT, {
+			escalation: {},
+			result: "full"
+		});
+		return "reported";
+	});
+}
+const FLAVOR_B_PROMPT = "reconcile the ledger discrepancies";
+const FLAVOR_B_OPTIONS = {
+	flavor: "B",
+	deadlineMs: 25,
+	defaultDecision: {
+		kind: "cancel",
+		reason: "nobody decided before the deadline"
+	}
+};
+/** The workflow of the flavor-b-timeout cassette; tests import it. */
+function flavorBTimeoutWorkflow() {
+	return defineWorkflow({ name: "flavor-b-timeout" }, async (ctx) => {
+		return (await ctx.agent(FLAVOR_B_PROMPT, {
+			escalation: FLAVOR_B_OPTIONS,
+			result: "full"
+		})).status;
+	});
+}
+const CLASSIFY_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["label"],
+	properties: { label: { type: "string" } }
+};
+/** The workflow of the re-recorded memoize-classifier cassette. */
+function memoizeClassifierWorkflow() {
+	return defineWorkflow({ name: "memoize-classifier" }, async (ctx) => {
+		await ctx.agent(PROMPTS.classify, {
+			schema: CLASSIFY_SCHEMA,
+			memoizeOutcome: true,
+			result: "full"
+		});
+		await ctx.agent(PROMPTS.summarize, {
+			memoizeOutcome: true,
+			result: "full"
+		});
+		return "classified";
+	});
+}
+async function recordEngineRun(options) {
+	const journal = new InMemoryStore();
+	const outcome = await createEngine({
+		adapters: [new FakeAdapter({ agents: options.agents })],
+		stores: { journal },
+		defaults: { routing: {
+			loop: FAKE_MODEL_REF,
+			extract: FAKE_MODEL_REF
+		} },
+		...options.onEscalation === void 0 ? {} : { onEscalation: options.onEscalation }
+	}).run(options.workflow, void 0, { runId: "record" }).result;
+	if (outcome.status !== "ok") throw new Error(`cassette recording run ended '${outcome.status}': ${outcome.error?.message ?? ""}`);
+	return normalizeEntries(await journal.load("record"));
+}
+/** A realistic validated report for the kernel-recorded escalated child. */
+function subtreeChildReport() {
+	return {
+		kind: "scope_bigger",
+		scopeDelta: "the child branch needs the whole schema registry",
+		revisedEstimate: {
+			usd: 12,
+			turns: 30
+		},
+		blockers: [],
+		proposedDecomposition: [],
+		costToDate: {
+			usd: 0,
+			turns: 2
+		},
+		salvage: {
+			transcriptRef: "record/t-child",
+			artifacts: []
+		}
+	};
+}
+/**
+* The orchestrator-subtree shape: written through the KERNEL write APIs
+* (the same calls mode (c) spawning uses from M6), since no script-mode
+* producer can spawn agents under an agent scope yet; re-recorded again
+* live in M7 with the orchestrator producers (docs/10, cassette plan).
+*/
+async function recordAbandonSubtree() {
+	let tick = 0;
+	const replayer = new Replayer({
+		runId: "record",
+		store: new InMemoryStore(),
+		now: () => BASE_MS + tick++ * 1e3
+	});
+	const parent = await replayer.appendRunning({
+		scope: "",
+		key: deriveContentKey(fakeAgentIdentity(PROMPTS.branchWork)),
+		kind: "agent",
+		spanId: SPAN
+	});
+	const subtree = agentScope("", parent.seq);
+	const okRunning = await replayer.appendRunning({
+		scope: subtree,
+		key: deriveContentKey(fakeAgentIdentity(PROMPTS.childOk)),
+		kind: "agent",
+		spanId: SPAN
+	});
+	await replayer.appendTerminal(okRunning.seq, {
+		status: "ok",
+		value: "child ok out",
+		usage: usageOf(100, 20),
+		servedBy: FAKE_MODEL_REF
+	});
+	const escalatedRunning = await replayer.appendRunning({
+		scope: subtree,
+		key: deriveContentKey(fakeAgentIdentity(PROMPTS.childEscalated)),
+		kind: "agent",
+		spanId: SPAN
+	});
+	await replayer.appendTerminal(escalatedRunning.seq, {
+		status: "escalated",
+		escalation: subtreeChildReport(),
+		usage: usageOf(200, 40),
+		servedBy: FAKE_MODEL_REF
+	});
+	await replayer.appendRunning({
+		scope: subtree,
+		key: deriveContentKey(fakeAgentIdentity(PROMPTS.childHanging)),
+		kind: "agent",
+		spanId: SPAN
+	});
+	const decision = await replayer.appendSinglePhase({
+		scope: "",
+		key: "",
+		kind: "decision",
+		status: "ok",
+		spanId: SPAN,
+		value: {
+			decisionType: "escalation.decision",
+			targetRef: escalatedRunning.seq,
+			decision: {
+				kind: "cancel",
+				reason: "owner cancelled the branch"
+			},
+			countsAgainstLimit: true
+		}
+	});
+	await replayer.abandonBranch({
+		target: parent.seq,
+		authorizedBy: decision.seq,
+		reason: "cancel_task"
+	});
+	return normalizeEntries(replayer.snapshot());
+}
+/**
+* Records the five live cassettes. Deterministic by construction:
+* scripted FakeAdapter responders, fixed runId, normalized stamps.
+*/
+/**
+* The v1 flow re-run under explicit high effort (DEF-6, M4-T08): the
+* body matches the frozen v1 journal's call sequence; the assessTone
+* call is the one genuinely new spawn and records with hashVersion 2
+* and canonical effort in identity.
+*/
+function effortShiftWorkflow() {
+	return defineWorkflow({ name: "v1-flow" }, async (ctx) => {
+		return {
+			draft: await ctx.agent(PROMPTS.draftSummary, { effort: "high" }),
+			saved: await ctx.step("persist-draft", () => ({
+				written: true,
+				path: "drafts/summary.md"
+			})),
+			stampMs: ctx.now(),
+			intro1: await ctx.agent(PROMPTS.polishIntro, { effort: "high" }),
+			intro2: await ctx.agent(PROMPTS.polishIntro, { effort: "high" }),
+			tone: await ctx.agent(PROMPTS.assessTone, { effort: "high" }),
+			approved: (await ctx.awaitExternal("editor-approval", {
+				schema: APPROVED_SCHEMA,
+				prompt: "Approve the draft?"
+			})).approved
+		};
+	});
+}
+/** Locates the frozen v1 journal from both src (vitest) and dist (script) layouts. */
+function frozenV1JournalPath() {
+	const candidates = [new URL("../../fixtures/frozen/v1-journal.jsonl", import.meta.url), new URL("../fixtures/frozen/v1-journal.jsonl", import.meta.url)];
+	for (const candidate of candidates) {
+		const path = fileURLToPath(candidate);
+		if (existsSync(path)) return path;
+	}
+	throw new Error("frozen v1-journal.jsonl not found next to the recorder");
+}
+/**
+* effort-defaults-shift (DEF-6; docs/10 M4 gating row): the frozen v1
+* prefix (recorded without effort) is closed offline the way an
+* operator would (the external resolves, the approval flow is
+* abandoned under its authority), then the SAME flow resumes LIVE under
+* a config requesting high effort with the completed effort semantics:
+* every v1 entry matches (the v1 predicate strips effort), and the one
+* new spawn records canonical effort in v2 identity.
+*/
+async function recordEffortDefaultsShift() {
+	const RUN = "RUNV1";
+	const v1Entries = readFileSync(frozenV1JournalPath(), "utf8").split("\n").filter((line) => line.trim() !== "").map((line) => normalizeEntry(JSON.parse(line)));
+	const journal = new InMemoryStore();
+	for (const entry of v1Entries) await journal.append(RUN, entry);
+	await journal.putMeta({
+		runId: RUN,
+		status: "suspended",
+		updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+		workflowName: "v1-flow"
+	});
+	const offline = new Replayer({
+		runId: RUN,
+		store: journal,
+		priorEntries: v1Entries
+	});
+	const resolved = await offline.resolveSuspended(5, {
+		by: "external",
+		value: { approved: true }
+	});
+	if (!resolved.applied) throw new Error("offline resolution of the v1 external did not apply");
+	if (!(await offline.abandonBranch({
+		target: 6,
+		authorizedBy: resolved.seq,
+		reason: "approval flow superseded by the operator"
+	})).applied) throw new Error("offline abandon of the v1 approval did not apply");
+	const outcome = await createEngine({
+		adapters: [new FakeAdapter({ agents: { "*": "tone assessed" } })],
+		stores: { journal },
+		defaults: { routing: {
+			loop: FAKE_MODEL_REF,
+			extract: FAKE_MODEL_REF
+		} }
+	}).resume(RUN, effortShiftWorkflow()).result;
+	if (outcome.status !== "ok") throw new Error(`effort-defaults-shift recording ended '${outcome.status}': ${outcome.error?.message ?? ""}`);
+	return normalizeEntries(await journal.load(RUN));
+}
+/**
+* A live engine over one durable store, for multi-leg recordings with
+* offline kernel writes between the legs (the M8 server/worker shape).
+*/
+function liveEngine(store, agents) {
+	return createEngine({
+		adapters: [new FakeAdapter({ agents })],
+		stores: { journal: store },
+		defaults: { routing: {
+			loop: FAKE_MODEL_REF,
+			extract: FAKE_MODEL_REF
+		} }
+	});
+}
+/** An offline kernel writer over the loaded priors (docs/03, section 8). */
+async function offlineReplayer(store, runId) {
+	let tick = 500;
+	return new Replayer({
+		runId,
+		store,
+		priorEntries: await store.load(runId),
+		now: () => BASE_MS + tick++ * 1e3
+	});
+}
+/** Polls the store until the external suspension is durable. */
+async function waitForSuspension(store, runId, key) {
+	for (let i = 0; i < 400; i += 1) {
+		if ((await store.load(runId)).some((entry) => entry.status === "suspended" && entry.value?.key === key)) return;
+		await new Promise((resolve) => setTimeout(resolve, 5));
+	}
+	throw new Error(`recording: the '${key}' suspension never landed`);
+}
+function suspendedSeqOf(entries, key) {
+	const suspended = entries.find((entry) => entry.status === "suspended" && entry.value?.key === key);
+	if (suspended === void 0) throw new Error(`recording: no suspended entry for external key '${key}'`);
+	return suspended.seq;
+}
+/**
+* DEF-4 timeout-vs-live-race, LIVE form: the run suspends on the
+* decision, the LIVE resolution wins through RunHandle.resolveExternal,
+* and the late timer attempt lands through the offline kernel writer as
+* the journaled noop (first-wins; docs/03, 8.6).
+*/
+async function recordTimeoutVsLiveRace() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "timeout-race" }, async (ctx) => {
+		return {
+			analysis: await ctx.agent(PROMPTS.analyze),
+			decision: (await ctx.awaitExternal("escalation-report", {
+				schema: DECISION_SCHEMA,
+				prompt: "Escalation decision required"
+			})).decision
+		};
+	});
+	const handle = liveEngine(store, { "*": "analysis: rollback recommended" }).run(wf, void 0, { runId: "record" });
+	await waitForSuspension(store, "record", "escalation-report");
+	const settle = await handle.result;
+	if (settle.status !== "suspended") throw new Error(`timeout-vs-live-race: expected the suspension settle, got '${settle.status}'`);
+	if (!(await handle.resolveExternal("escalation-report", { decision: "rollback" })).applied) throw new Error("timeout-vs-live-race: the live resolution must win");
+	const replayer = await offlineReplayer(store, "record");
+	const target = suspendedSeqOf(await store.load("record"), "escalation-report");
+	if ((await replayer.resolveSuspended(target, {
+		by: "timeout",
+		value: { decision: "abort" }
+	})).applied) throw new Error("timeout-vs-live-race: the timeout attempt must land as a noop");
+	const outcome = await liveEngine(store, { "*": "analysis: rollback recommended" }).resume("record", wf).result;
+	if (outcome.status !== "ok") throw new Error(`timeout-vs-live-race: the resume ended '${outcome.status}'`);
+	return normalizeEntries(await store.load("record"));
+}
+/**
+* DEF-4 class-decision-fanout, LIVE form: three sequential suspensions;
+* the first closes individually (applied by external); ONE class-level
+* decision entry closes the remaining two by class_decision with the
+* decisionRef, and the late class attempt against the first lands noop
+* (docs/03, 8.6; the plan-side class producer has its own cassette,
+* class-storm-single-turn).
+*/
+async function recordClassDecisionFanout() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "fanout" }, async (ctx) => {
+		const one = await ctx.awaitExternal("report-1");
+		const two = await ctx.awaitExternal("report-2");
+		const three = await ctx.awaitExternal("report-3");
+		return [
+			one.action,
+			two.action,
+			three.action
+		];
+	});
+	const first = liveEngine(store, {}).run(wf, void 0, { runId: "record" });
+	await waitForSuspension(store, "record", "report-1");
+	const settle1 = await first.result;
+	if (settle1.status !== "suspended") throw new Error(`class-decision-fanout: expected the report-1 settle, got '${settle1.status}'`);
+	if (!(await first.resolveExternal("report-1", { action: "retry" })).applied) throw new Error("class-decision-fanout: the individual close must apply");
+	const leg2 = await liveEngine(store, {}).resume("record", wf).result;
+	if (leg2.status !== "suspended") throw new Error(`class-decision-fanout: expected the report-2 settle, got '${leg2.status}'`);
+	const replayer = await offlineReplayer(store, "record");
+	const decision = await replayer.appendSinglePhase({
+		scope: "",
+		key: "",
+		kind: "decision",
+		status: "ok",
+		spanId: SPAN,
+		value: {
+			decisionType: "escalation.class",
+			decision: { kind: "retry" },
+			coverage: "all pending reports of this class"
+		}
+	});
+	const entriesNow = await store.load("record");
+	if (!(await replayer.resolveSuspended(suspendedSeqOf(entriesNow, "report-2"), {
+		by: "class_decision",
+		value: { action: "retry" },
+		decisionRef: decision.seq
+	})).applied) throw new Error("class-decision-fanout: the class close of report-2 must apply");
+	if ((await replayer.resolveSuspended(suspendedSeqOf(entriesNow, "report-1"), {
+		by: "class_decision",
+		value: { action: "retry" },
+		decisionRef: decision.seq
+	})).applied) throw new Error("class-decision-fanout: the class attempt on report-1 must land noop");
+	const secondSettle = await liveEngine(store, {}).resume("record", wf).result;
+	if (secondSettle.status !== "suspended") throw new Error(`class-decision-fanout: expected report-3 to suspend, got '${secondSettle.status}'`);
+	if (!(await (await offlineReplayer(store, "record")).resolveSuspended(suspendedSeqOf(await store.load("record"), "report-3"), {
+		by: "class_decision",
+		value: { action: "retry" },
+		decisionRef: decision.seq
+	})).applied) throw new Error("class-decision-fanout: the class close of report-3 must apply");
+	const final = await liveEngine(store, {}).resume("record", wf).result;
+	if (final.status !== "ok") throw new Error(`class-decision-fanout: the final resume ended '${final.status}'`);
+	return normalizeEntries(await store.load("record"));
+}
+/**
+* DEF-4 abandon-then-crash-then-resume, LIVE form: the paid branch is
+* abandoned offline (decision plus abandon through the kernel writer),
+* the crash cut drops the effects, and the resume derives skipped for
+* the branch while paying the revision effects exactly once.
+*/
+async function recordAbandonThenCrashThenResume() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "crash-resume" }, async (ctx) => {
+		if ((await ctx.agent(PROMPTS.reviseReport, { result: "full" })).status !== "skipped") return "branch unexpectedly ran";
+		return ctx.agent(PROMPTS.revisionEffects);
+	});
+	const scratch = new InMemoryStore();
+	const outcome1 = await liveEngine(scratch, { "*": "branch out" }).run(wf, void 0, { runId: "record" }).result;
+	if (outcome1.status !== "ok") throw new Error(`abandon-then-crash: life 1 ended '${outcome1.status}'`);
+	const scratchEntries = await scratch.load("record");
+	const branchTerminal = scratchEntries.find((entry) => entry.kind === "agent" && entry.ref !== void 0);
+	if (branchTerminal === void 0) throw new Error("abandon-then-crash: the branch terminal is missing");
+	for (const meta of await scratch.listRuns()) if (meta.runId === "record") await store.putMeta({
+		...meta,
+		status: "suspended"
+	});
+	for (const entry of scratchEntries) if (entry.seq <= branchTerminal.seq) await store.append("record", entry);
+	const replayer = await offlineReplayer(store, "record");
+	const branchRoot = (await store.load("record")).find((entry) => entry.kind === "agent" && entry.ref === void 0);
+	if (branchRoot === void 0) throw new Error("abandon-then-crash: the branch root is missing");
+	if (!(await replayer.abandonBranch({
+		target: branchRoot.seq,
+		authorizedBy: branchRoot.seq,
+		reason: "plan revision"
+	})).applied) throw new Error("abandon-then-crash: the abandon must apply");
+	const outcome2 = await liveEngine(store, { "*": "fresh live output" }).resume("record", wf).result;
+	if (outcome2.status !== "ok" || outcome2.value !== "fresh live output") throw new Error(`abandon-then-crash: the resume must pay the effects once, got '${outcome2.status}'`);
+	return normalizeEntries(await store.load("record"));
+}
+/**
+* DEF-4 abandon-vs-resolution-race, LIVE form: both orders through the
+* kernel writer over one journal: an abandon covering a suspension makes
+* the late resolution a noop (target_abandoned); the reverse order
+* applies the resolution and the late abandon folds noop.
+*/
+async function recordAbandonVsResolutionRace() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "race-directions" }, async (ctx) => {
+		const alpha = await ctx.agent(PROMPTS.branchAlpha, { result: "full" });
+		const beta = await ctx.awaitExternal("beta-gate", { schema: GO_SCHEMA });
+		return {
+			alphaStatus: alpha.status,
+			go: beta.go
+		};
+	});
+	const settle1 = await liveEngine(store, { "*": "alpha branch out" }).run(wf, void 0, { runId: "record" }).result;
+	if (settle1.status !== "suspended") throw new Error(`abandon-vs-resolution: expected the beta suspension, got '${settle1.status}'`);
+	const replayer = await offlineReplayer(store, "record");
+	const loaded = await store.load("record");
+	const alphaRoot = loaded.find((entry) => entry.kind === "agent" && entry.ref === void 0);
+	if (alphaRoot === void 0) throw new Error("abandon-vs-resolution: the alpha root is missing");
+	const innerApproval = await replayer.appendSuspended({
+		scope: agentScope("", alphaRoot.seq),
+		key: "",
+		kind: "approval",
+		spanId: SPAN,
+		value: {
+			toolName: "deploy",
+			input: { env: "prod" }
+		}
+	});
+	if (!(await replayer.abandonBranch({
+		target: alphaRoot.seq,
+		authorizedBy: alphaRoot.seq,
+		reason: "abandon first"
+	})).applied) throw new Error("abandon-vs-resolution: the covering abandon must apply");
+	if ((await replayer.resolveSuspended(innerApproval.seq, {
+		by: "external",
+		value: { approved: true }
+	})).applied) throw new Error("abandon-vs-resolution: the covered resolution must land noop");
+	const betaSeq = suspendedSeqOf(loaded, "beta-gate");
+	if (!(await replayer.resolveSuspended(betaSeq, {
+		by: "external",
+		value: { go: true }
+	})).applied) throw new Error("abandon-vs-resolution: the beta resolution must apply");
+	if ((await replayer.abandonBranch({
+		target: betaSeq,
+		authorizedBy: alphaRoot.seq,
+		reason: "abandon second"
+	})).applied) throw new Error("abandon-vs-resolution: the late abandon must fold noop");
+	return normalizeEntries(await store.load("record"));
+}
+/**
+* DEF-4 offline-invalid-then-valid, LIVE form (the M8 server machinery
+* end to end): the run suspends on a schema-validated external; the
+* offline writer appends an INVALID then a VALID resolution; the resume
+* consumes the valid value with zero live calls inside the suspension.
+*/
+async function recordOfflineInvalidThenValid() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "invalid-then-valid" }, async (ctx) => {
+		return (await ctx.awaitExternal("deploy-approval", {
+			schema: APPROVED_SCHEMA,
+			prompt: "Approve the deployment?"
+		})).approved;
+	});
+	const settle1 = await liveEngine(store, {}).run(wf, void 0, { runId: "record" }).result;
+	if (settle1.status !== "suspended") throw new Error(`offline-invalid-then-valid: expected suspended, got '${settle1.status}'`);
+	const replayer = await offlineReplayer(store, "record");
+	const target = suspendedSeqOf(await store.load("record"), "deploy-approval");
+	if ((await replayer.resolveSuspended(target, {
+		by: "external",
+		value: { approved: "yes-ish" }
+	})).applied) throw new Error("offline-invalid-then-valid: the invalid payload must not close");
+	if (!(await replayer.resolveSuspended(target, {
+		by: "external",
+		value: { approved: true }
+	})).applied) throw new Error("offline-invalid-then-valid: the valid payload must apply");
+	const outcome = await liveEngine(store, {}).resume("record", wf).result;
+	if (outcome.status !== "ok" || outcome.value !== true) throw new Error(`offline-invalid-then-valid: the resume ended '${outcome.status}'`);
+	return normalizeEntries(await store.load("record"));
+}
+/**
+* DEF-4 double-abandon-idempotent, LIVE form: two covering abandons over
+* overlapping targets through the kernel writer; the second folds noop,
+* the terminal ok inside the coverage derives skipped, and the ledger
+* pays nothing on replay.
+*/
+async function recordDoubleAbandonIdempotent() {
+	const store = new InMemoryStore();
+	const wf = defineWorkflow({ name: "double-abandon" }, async (ctx) => {
+		return (await ctx.agent(PROMPTS.subtreeAlpha, { result: "full" })).status;
+	});
+	const settle1 = await liveEngine(store, { "*": "alpha done" }).run(wf, void 0, { runId: "record" }).result;
+	if (settle1.status !== "ok") throw new Error(`double-abandon: life 1 ended '${settle1.status}'`);
+	const replayer = await offlineReplayer(store, "record");
+	const root = (await store.load("record")).find((entry) => entry.kind === "agent" && entry.ref === void 0);
+	if (root === void 0) throw new Error("double-abandon: the alpha root is missing");
+	if (!(await replayer.abandonBranch({
+		target: root.seq,
+		authorizedBy: root.seq,
+		reason: "first cancel"
+	})).applied) throw new Error("double-abandon: the first abandon must apply");
+	if ((await replayer.abandonBranch({
+		target: root.seq,
+		authorizedBy: root.seq,
+		reason: "second cancel overlaps"
+	})).applied) throw new Error("double-abandon: the second abandon must fold noop");
+	return normalizeEntries(await store.load("record"));
+}
+async function recordLiveCassettes() {
+	const fixtures = [];
+	fixtures.push({
+		id: "effort-defaults-shift",
+		note: "DEF-6 (recorded through the live runtime in M4-T08): the frozen v1 prefix recorded without effort, closed offline, then resumed live under explicit high effort with the completed effort semantics; every v1 entry matches (the v1 predicate strips effort) and the one new spawn carries canonical effort in v2 identity.",
+		entries: await recordEffortDefaultsShift()
+	});
+	fixtures.push({
+		id: "abandon-subtree",
+		note: "DEF-1 (re-recorded through the kernel write APIs in M3): abandon over a subtree with ok, escalated, and a hanging running entry, authorized by the owner cancel decision; all derive skipped, zero live calls, zero spend increment.",
+		entries: await recordAbandonSubtree()
+	});
+	fixtures.push({
+		id: "memoize-classifier",
+		note: "DEF-1 (re-recorded through the live runtime in M3): memoizeOutcome pins the task-class failure (schema mismatch) for replay; the transport-class failure (rate limit) reruns and is the expected strict miss.",
+		entries: await recordEngineRun({
+			workflow: memoizeClassifierWorkflow(),
+			agents: {
+				"summarize the document": () => fakeWireError({
+					code: "rate-limit",
+					message: "429 too many requests",
+					retryable: true,
+					data: {
+						kind: "rate-limit",
+						retryAfterMs: 1e3
+					}
+				}),
+				"*": "this is not the requested JSON, just prose"
+			}
+		}).then((entries) => {
+			return entries;
+		})
+	});
+	fixtures.push({
+		id: "escalate-replay",
+		note: "DEF-1 live set: the worker finishes escalated with a report, the parent decides retry (journaled escalation.decision), and the respawn completes; replay-strict resume yields zero live calls, the byte-identical report, and the decision from the entry.",
+		entries: await recordEngineRun({
+			workflow: escalateReplayWorkflow(),
+			agents: {
+				"migrate the billing": () => fakeToolCalls({
+					name: "escalate",
+					args: RECORDED_ESCALATE_ARGS
+				}),
+				"retry: split the billing": "migration retried per service"
+			},
+			onEscalation: () => ({
+				kind: "retry",
+				amendedPrompt: "split by service"
+			})
+		})
+	});
+	fixtures.push({
+		id: "crash-between-report-and-decision",
+		note: "DEF-1 live set: the terminal escalated entry landed, the process died before any decision; the first resume replays escalated and pays for the decision live exactly once; the second resume replays both with zero live calls.",
+		entries: await recordEngineRun({
+			workflow: crashBetweenPhase1Workflow(),
+			agents: { "stabilize the flaky": () => fakeToolCalls({
+				name: "escalate",
+				args: RECORDED_ESCALATE_ARGS
+			}) }
+		})
+	});
+	fixtures.push({
+		id: "timeout-vs-live-race",
+		note: "DEF-4 (re-recorded through the live producers in M9): the live resolution wins through RunHandle.resolveExternal; the late timer attempt lands through the offline kernel writer as the journaled noop whose effects never re-issue (docs/03, 8.6).",
+		entries: await recordTimeoutVsLiveRace()
+	});
+	fixtures.push({
+		id: "class-decision-fanout",
+		note: "DEF-4 (re-recorded through the live producers in M9): report-1 closes individually; ONE class-level decision closes the remaining reports by class_decision with the decisionRef; the late class attempt on report-1 lands noop; the plan-side class producer has its own cassette (class-storm-single-turn).",
+		entries: await recordClassDecisionFanout()
+	});
+	fixtures.push({
+		id: "abandon-then-crash-then-resume",
+		note: "DEF-4 (re-recorded through the live producers in M9): the paid branch is abandoned through the offline kernel writer (decision plus abandon), the crash cut drops the effects, and the resume derives skipped while paying the effects exactly once.",
+		entries: await recordAbandonThenCrashThenResume()
+	});
+	fixtures.push({
+		id: "abandon-vs-resolution-race",
+		note: "DEF-4 (re-recorded through the live producers in M9): both orders over one journal; an abandon covering a suspension makes the late resolution a noop target_abandoned; the reverse order applies the resolution and the late abandon folds noop.",
+		entries: await recordAbandonVsResolutionRace()
+	});
+	fixtures.push({
+		id: "offline-invalid-then-valid",
+		note: "DEF-4 (re-recorded through the live producers in M9, the M8 offline machinery end to end): the offline writer appends an INVALID then a VALID resolution against the schema-validated suspension; the resume consumes the valid value.",
+		entries: await recordOfflineInvalidThenValid()
+	});
+	fixtures.push({
+		id: "double-abandon-idempotent",
+		note: "DEF-4 (re-recorded through the live producers in M9): two covering abandons over one target; the second folds noop, the terminal ok inside the coverage derives skipped, and replay pays nothing.",
+		entries: await recordDoubleAbandonIdempotent()
+	});
+	fixtures.push({
+		id: "flavor-b-timeout",
+		note: "DEF-1 live set: the escalate tool suspends the agent with a journaled deadline; the timer appends the resolution by timeout applying the defaultDecision (first-wins); dispose and the terminal escalated entry follow as effects; resume replays the closing resolution and the terminal entry with no re-suspension.",
+		entries: await recordEngineRun({
+			workflow: flavorBTimeoutWorkflow(),
+			agents: { "reconcile the ledger": () => fakeToolCalls({
+				name: "escalate",
+				args: RECORDED_ESCALATE_ARGS
+			}) }
+		})
+	});
+	return fixtures;
+}
+//#endregion
+//#region src/cassettes/m6-orchestrator.ts
+const M6_ORCH_RUN_ID = "m6-orchestrator-crash";
+const M6_ORCH_GOAL = "m6 cassette: gather two facts";
+const M6_ORCH_PROFILES = { worker: { description: "does one task" } };
+function agentTypeOf(call) {
+	return (call.req.providerOptions?.rulvar)?.agentType ?? "";
+}
+/** Extracts spawn handles from the tool results the model saw. */
+function handlesInRequest(req) {
+	const handles = [];
+	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") handles.push(result.handle);
+	}
+	return handles;
+}
+/** Fixes wall clock and spans; everything else is deterministic already. */
+function normalizeM6Entries(entries) {
+	return entries.map((entry) => ({
+		...entry,
+		spanId: "fixture-span",
+		startedAt: "2026-02-01T00:00:00.000Z",
+		...entry.endedAt === void 0 ? {} : { endedAt: "2026-02-01T00:00:00.000Z" }
+	}));
+}
+/**
+* Phase 1: record the pre-crash journal. The transcripts store carries
+* the boundary checkpoint the resume restores from; the recorder keeps
+* it in memory because the cassette pins only journal bytes (checkpoint
+* blobs are engine-internal at-least-once state, docs/03 section 11).
+*/
+async function recordOrchestratorCrash() {
+	let orchestratorTurn = 0;
+	const adapter = new FakeAdapter({ agents: { "*": (call) => {
+		if (agentTypeOf(call) === "worker") return `paid: ${call.prompt}`;
+		orchestratorTurn += 1;
+		if (orchestratorTurn === 1) return fakeToolCalls({
+			name: "spawn_agent",
+			args: {
+				agentType: "worker",
+				prompt: "expensive A"
+			}
+		}, {
+			name: "spawn_agent",
+			args: {
+				agentType: "worker",
+				prompt: "expensive B"
+			}
+		});
+		return fakeWireError({
+			code: "agent",
+			message: "simulated crash",
+			retryable: false
+		});
+	} } });
+	const store = new InMemoryStore();
+	const transcripts = new InMemoryTranscriptStore();
+	const engine = createEngine({
+		adapters: [adapter],
+		stores: {
+			journal: store,
+			transcripts
+		},
+		defaults: {
+			routing: {
+				loop: FAKE_MODEL_REF,
+				orchestrate: FAKE_MODEL_REF
+			},
+			profiles: M6_ORCH_PROFILES
+		}
+	});
+	const wf = makeOrchestratorWorkflow(M6_ORCH_GOAL, {});
+	const outcome = await engine.run(wf, void 0, { runId: M6_ORCH_RUN_ID }).result.then((settled) => settled);
+	if (outcome.status !== "error") throw new Error(`the recorder expected a crashed run, got '${outcome.status}'`);
+	const entries = await store.load(M6_ORCH_RUN_ID);
+	const orchestratorTerminal = entries.find((entry) => entry.kind === "agent" && !entry.scope.startsWith("agent:") && entry.status !== "running" && entry.status !== "suspended");
+	if (orchestratorTerminal === void 0) throw new Error("the recorder found no orchestrator terminal to cut");
+	const cut = entries.filter((entry) => entry.seq < orchestratorTerminal.seq);
+	const checkpoints = {};
+	for (const ref of await transcripts.list(M6_ORCH_RUN_ID)) {
+		if (!ref.includes("/ckpt/")) continue;
+		const blob = await transcripts.get(ref);
+		if (blob !== null) checkpoints[ref] = Buffer.from(blob).toString("base64");
+	}
+	return {
+		entries: normalizeM6Entries(cut),
+		checkpoints
+	};
+}
+//#endregion
+//#region src/vcr.ts
+/**
+* VCR cassettes at the adapter boundary (M5-T04; docs/09, section 5.2;
+* docs/11, section 5): `record` wraps live adapters and captures
+* request/event pairs into a redacted JSONL cassette keyed by a hash of
+* the canonical wire-contract request; `replay` serves recorded streams
+* back with `onMiss: 'throw'` (hermetic CI) or `'passthrough'` (mixed
+* live/recorded development runs). Because the boundary speaks the L0
+* wire contract, cassettes are vendor-neutral by construction.
+*
+* Redaction happens at record time and secrets MUST never reach the
+* committed cassette bytes: the built-in policy masks authorization
+* material (bearer tokens, api-key-shaped strings) in every stored
+* string, and a `redact` hook composes on top. The request HASH is
+* computed over the raw canonical request (minus the engine-populated
+* `providerOptions.rulvar` telemetry namespace, which is never
+* identity), so replay matching is redaction-independent while stored
+* bytes stay clean. Cassettes record the hashVersion they were produced
+* under (DEF-6).
+*/
+/**
+* Built-in redaction: authorization material never reaches cassette
+* bytes (docs/11, section 5.2). Deliberately aggressive; compose a
+* custom hook for payload-specific secrets.
+*/
+function defaultRedact(value) {
+	return value.replace(/\b(sk|pk|rk)-[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [REDACTED]").replace(/\b(api[-_]?key|authorization|x-api-key)(["':\s=]+)((?!Bearer\b)[^\s"',;]+)/gi, "$1$2[REDACTED]");
+}
+function walkStrings(value, fn) {
+	if (typeof value === "string") return fn(value);
+	if (Array.isArray(value)) return value.map((item) => walkStrings(item, fn));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, walkStrings(item, fn)]));
+	return value;
+}
+/** Deterministic canonical JSON: sorted keys, no whitespace. */
+function canonicalJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+	return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+}
+/**
+* The cassette key: a hash of the canonical wire-contract request. The
+* engine-populated telemetry namespace is excluded (docs/04, section
+* 1.8: never identity); everything else the adapter would send keys the
+* row.
+*/
+function requestHash(req) {
+	const { providerOptions, ...rest } = req;
+	const filtered = providerOptions === void 0 ? {} : Object.fromEntries(Object.entries(providerOptions).filter(([namespace]) => namespace !== "rulvar"));
+	const withoutTelemetry = Object.keys(filtered).length === 0 ? rest : {
+		...rest,
+		providerOptions: filtered
+	};
+	return createHash("sha256").update(canonicalJson(withoutTelemetry), "utf8").digest("hex");
+}
+function headerLine() {
+	return JSON.stringify({
+		v: 1,
+		kind: "rulvar-vcr",
+		hashVersion: CURRENT_HASH_VERSION,
+		recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/**
+* Wraps live adapters for recording: every completed stream appends one
+* redacted row to the cassette JSONL. The wrapped adapters are drop-in:
+* same ids, providers, caps, and event streams.
+*/
+function record(options) {
+	const redact = options.redact ? (value) => defaultRedact(options.redact ? options.redact(value) : value) : defaultRedact;
+	if (!existsSync(options.cassette)) writeFileSync(options.cassette, `${headerLine()}\n`, "utf8");
+	return options.adapters.map((adapter) => ({
+		...adapter,
+		id: adapter.id,
+		...adapter.provider === void 0 ? {} : { provider: adapter.provider },
+		caps: (model) => adapter.caps(model),
+		async *stream(req, signal) {
+			const events = [];
+			for await (const event of adapter.stream(req, signal)) {
+				events.push(event);
+				yield event;
+			}
+			const row = {
+				adapterId: adapter.id,
+				...adapter.provider === void 0 ? {} : { provider: adapter.provider },
+				requestHash: requestHash(req),
+				request: walkStrings(JSON.parse(JSON.stringify(req)), redact),
+				events: walkStrings(JSON.parse(JSON.stringify(events)), redact),
+				caps: adapter.caps(req.model),
+				model: req.model
+			};
+			appendFileSync(options.cassette, `${JSON.stringify(row)}\n`, "utf8");
+		}
+	}));
+}
+/** Typed hermetic-miss error; onMiss: 'throw' raises it on any unrecorded request. */
+var VcrMissError = class extends Error {
+	requestHash;
+	constructor(adapterId, hash) {
+		super(`VCR miss: adapter '${adapterId}' received a request with no recorded row (hash ${hash.slice(0, 12)}); onMiss: 'throw' keeps cassette tests hermetic`);
+		this.name = "VcrMissError";
+		this.requestHash = hash;
+	}
+};
+/** Parses a cassette file (one header line plus one JSON row per line). */
+function readCassette(path) {
+	const lines = readFileSync(path, "utf8").split("\n").filter((line) => line.trim() !== "");
+	const header = JSON.parse(lines[0] ?? "{}");
+	if (header.kind !== "rulvar-vcr") throw new ConfigError(`${path} is not a rulvar VCR cassette`);
+	return {
+		header,
+		rows: lines.slice(1).map((line) => JSON.parse(line))
+	};
+}
+/**
+* Builds replay adapters from a cassette. `onMiss: 'throw'` is the
+* hermetic CI mode; `'passthrough'` forwards unrecorded requests to the
+* matching live adapter in `adapters` (a development convenience only,
+* docs/11 section 5.1).
+*/
+function replay(options) {
+	const { rows } = readCassette(options.cassette);
+	const byAdapter = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const forAdapter = byAdapter.get(row.adapterId) ?? /* @__PURE__ */ new Map();
+		forAdapter.set(row.requestHash, row);
+		byAdapter.set(row.adapterId, forAdapter);
+	}
+	const live = new Map((options.adapters ?? []).map((adapter) => [adapter.id, adapter]));
+	return [.../* @__PURE__ */ new Set([...byAdapter.keys(), ...live.keys()])].map((adapterId) => {
+		const recorded = byAdapter.get(adapterId) ?? /* @__PURE__ */ new Map();
+		const passthrough = live.get(adapterId);
+		const someRow = [...recorded.values()][0];
+		const capsByModel = /* @__PURE__ */ new Map();
+		for (const row of recorded.values()) capsByModel.set(row.model, row.caps);
+		return {
+			id: adapterId,
+			...someRow?.provider === void 0 ? {} : { provider: someRow.provider },
+			caps: (model) => {
+				const snapshot = capsByModel.get(model) ?? passthrough?.caps(model);
+				if (snapshot === void 0) throw new ConfigError(`VCR replay adapter '${adapterId}' has no caps snapshot for model '${model}'`);
+				return snapshot;
+			},
+			async *stream(req, signal) {
+				const hash = requestHash(req);
+				const row = recorded.get(hash);
+				if (row !== void 0) {
+					for (const event of row.events) yield event;
+					return;
+				}
+				if (options.onMiss === "passthrough" && passthrough !== void 0) {
+					yield* passthrough.stream(req, signal);
+					return;
+				}
+				throw new VcrMissError(adapterId, hash);
+			}
+		};
+	});
+}
+//#endregion
+export { FAKE_MODEL, FAKE_MODEL_REF, FakeAdapter, M6_ORCH_GOAL, M6_ORCH_PROFILES, M6_ORCH_RUN_ID, VcrMissError, buildFrozenV1JournalRaw, buildM2CassetteFixtures, buildV2GoldenIdentity, createTestEngine, defaultRedact, fakeToolCalls, fakeWireError, handlesInRequest, normalizeM6Entries, readCassette, record, recordLiveCassettes, recordOrchestratorCrash, replay, replayRun, requestHash };