@morlay/session-rdb 0.0.14 → 0.0.16-alpha.0

package/dist/testing.mjs

@@ -1,8 +1,8 @@
-import SessionStore, { SESSION_FORMAT_VERSION, Session, SessionId, SessionLogOffset, SessionSeq, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from "@deepseek-ai/dsh-session";
+import { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionPersistenceNotFoundError, SessionReadOnlyError } from "@deepseek-ai/dsh-session-persistence";
+import SessionStore, { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
 import { SettingsProvider } from "@deepseek-ai/dsh-settings";
-import { MessageId, ToolCallId, createMessage, createUserMessage, freezeMessage } from "@deepseek-ai/dsh-llm";
+import { MessageId, createUserMessage, freezeMessage } from "@deepseek-ai/dsh-llm";
 import { Context } from "@deepseek-ai/cordis";
-import { scopeTarget } from "@deepseek-ai/dsh-scope";
 //#region src/testing/helpers.ts
 var EmptySettings = class extends SettingsProvider {
 	constructor(ctx) {
@@ -5116,7 +5116,7 @@ function manageArtifactAttachment(attachment) {
 	if (attachment.body != null) attachment.bodyEncoding ??= "base64";
 }
 //#endregion
-//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.4.1_happy-dom@20.13.2_vite@8.2.2__685d385505d44d75e67f1bad705abef7/node_modules/vitest/dist/chunks/utils.BX5Fg8C4.js
+//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.5.0_happy-dom@20.13.2_vite@8.2.2__9bde3b9553ba3388013323e9f29b314e/node_modules/vitest/dist/chunks/utils.BX5Fg8C4.js
 const NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
 	const workerState = globalThis[NAME_WORKER_STATE];
@@ -10019,10 +10019,10 @@ function offsetToLineNumber(source, offset) {
 	return line + 1;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.4.1_happy-dom@20.13.2_vite@8.2.2__685d385505d44d75e67f1bad705abef7/node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js
+//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.5.0_happy-dom@20.13.2_vite@8.2.2__9bde3b9553ba3388013323e9f29b314e/node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 //#endregion
-//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.4.1_happy-dom@20.13.2_vite@8.2.2__685d385505d44d75e67f1bad705abef7/node_modules/vitest/dist/chunks/rpc.MzXet3jl.js
+//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.5.0_happy-dom@20.13.2_vite@8.2.2__9bde3b9553ba3388013323e9f29b314e/node_modules/vitest/dist/chunks/rpc.MzXet3jl.js
 const RealDate = Date;
 let now = null;
 var MockDate = class MockDate extends RealDate {
@@ -10987,7 +10987,7 @@ function raceWith(promise, other) {
 	}))]);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.4.1_happy-dom@20.13.2_vite@8.2.2__685d385505d44d75e67f1bad705abef7/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js
+//#region ../../node_modules/.pnpm/vitest@4.1.11_@opentelemetry+api@1.9.1_@types+node@26.5.0_happy-dom@20.13.2_vite@8.2.2__9bde3b9553ba3388013323e9f29b314e/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js
 var fakeTimersSrc = {};
 var global$1;
 var hasRequiredGlobal;
@@ -13675,6 +13675,7 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 });
 //#endregion
 //#region src/testing/contract.ts
+/** Build a minimal {@link SessionHeader} for a session id. */
 function meta(id, cwd) {
 	return {
 		version: SESSION_FORMAT_VERSION,
@@ -13684,6 +13685,7 @@ function meta(id, cwd) {
 		...cwd === void 0 ? {} : { cwd }
 	};
 }
+/** A well-formed one-turn event log (contiguous seqs from 0). */
 function oneTurnLog() {
 	return [
 		{
@@ -13735,7 +13737,45 @@ function oneTurnLog() {
 						provider: "mock",
 						model: "mock"
 					}
-				})
+				}),
+				stream: [
+					{
+						type: "chunk",
+						time: 3,
+						chunk: {
+							type: "block-start",
+							index: 0,
+							blockType: "text"
+						}
+					},
+					{
+						type: "text-chunks",
+						time0: 3,
+						index: 0,
+						dt: [],
+						texts: ["hello"]
+					},
+					{
+						type: "chunk",
+						time: 4,
+						chunk: {
+							type: "block-end",
+							index: 0,
+							block: {
+								type: "text",
+								text: "hello"
+							}
+						}
+					},
+					{
+						type: "chunk",
+						time: 4,
+						chunk: {
+							type: "finish",
+							reason: { kind: "stop" }
+						}
+					}
+				]
 			},
 			surfaceOp: "append"
 		},
@@ -13759,6 +13799,23 @@ function oneTurnLog() {
 		}
 	];
 }
+/** A contiguous second-turn batch continuing {@link oneTurnLog}. */
+function secondTurn(startSeq = 6) {
+	return [{
+		type: "turn/start",
+		seq: SessionSeq(startSeq),
+		time: 9,
+		data: { turn: 2 }
+	}, {
+		type: "turn/end",
+		seq: SessionSeq(startSeq + 1),
+		time: 10,
+		data: {
+			turn: 2,
+			reason: { kind: "completed" }
+		}
+	}];
+}
 function appendLog(session, events) {
 	for (const e of events) {
 		const se = e;
@@ -13771,123 +13828,115 @@ function appendLog(session, events) {
 		} else session.append(e.type, e.data);
 	}
 }
+/**
+* Run the backend-agnostic handle contract suite. `make()` MUST return a
+* fresh backend over fresh, empty storage each call.
+* @param name - suite label, e.g. `jsonl-none` / `sqlite`.
+* @param make - factory producing one fresh {@link ContractBackend} per test.
+*/
 function runPersistenceContract(name, make) {
 	describe(`SessionPersistence contract: ${name}`, () => {
-		it("round-trips a session: create + append → load returns identical meta and byte-identical events", async () => {
+		it("round-trips through one write handle: append, self-read, offset/length defaults", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("s1", "/work");
+				const m = meta("round-trip", "/work");
 				const log = oneTurnLog();
-				await persistence.create(m);
-				await persistence.append(m.id, log);
-				const loaded = await persistence.load(m.id);
-				globalExpect(loaded.meta).toMatchObject({
-					version: SESSION_FORMAT_VERSION,
-					id: m.id,
-					cwd: "/work"
-				});
-				globalExpect(loaded.events).toEqual(log);
+				const handle = await persistence.create(m);
+				globalExpect(handle.access).toBe("write");
+				globalExpect(handle.id).toBe(m.id);
+				globalExpect(handle.header).toMatchObject(m);
+				await handle.append(log);
+				await handle.append([]);
+				const full = await handle.read();
+				globalExpect(full.events).toEqual(log);
+				globalExpect((await handle.read(3)).events).toEqual(log.slice(3));
+				globalExpect((await handle.read(0, 2)).events).toEqual(log.slice(0, 2));
+				globalExpect((await handle.read(1, 3)).events).toEqual(log.slice(1, 4));
+				globalExpect((await handle.read(log.length)).events).toEqual([]);
+				globalExpect((await handle.read(log.length + 100)).events).toEqual([]);
+				await handle.flush();
+				await handle.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("rejects a fractional creation timestamp without reserving its session id", async () => {
+		it("read rejects negative or fractional offsets and lengths", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = {
-					...meta("fractional-created-at"),
-					createdAt: 1.5
-				};
-				await globalExpect(persistence.create(m)).rejects.toThrow("session metadata createdAt must be a non-negative safe integer");
-				const valid = meta("fractional-created-at");
-				await persistence.create(valid);
-				await persistence.append(valid.id, oneTurnLog());
-				globalExpect((await persistence.load(valid.id)).meta.createdAt).toBe(valid.createdAt);
+				const handle = await persistence.create(meta("read-args"));
+				await globalExpect(handle.read(-1)).rejects.toThrow(/non-negative safe integer/);
+				await globalExpect(handle.read(1.5)).rejects.toThrow(/non-negative safe integer/);
+				await globalExpect(handle.read(0, -1)).rejects.toThrow(/non-negative safe integer/);
+				await handle.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("crash recovery: load preserves an interrupted (unclosed) turn and closes it with turn/end {interrupted}", async () => {
+		it("duplicate create rejects against a live pending session and allows the id after an erasing close", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("interrupted");
-				await persistence.create(m);
-				await persistence.append(m.id, oneTurnLog());
-				await persistence.append(m.id, [{
-					type: "turn/start",
-					seq: SessionSeq(6),
-					time: 7,
-					data: { turn: 2 }
-				}, {
-					type: "step/start",
-					seq: SessionSeq(7),
-					time: 8,
-					data: {
-						turn: 2,
-						step: 1
-					}
-				}]);
-				const beforeRepair = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id)?.revision;
-				const inspected = await persistence.inspect(m.id);
-				const afterInspect = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id)?.revision;
-				globalExpect(afterInspect).toBe(beforeRepair);
-				globalExpect(inspected.events.map((e) => e.type)).toEqual([
-					"turn/start",
-					"user/message",
-					"step/start",
-					"assistant/message",
-					"step/end",
-					"turn/end",
-					"turn/start",
-					"step/start",
-					"step/end",
-					"turn/end"
-				]);
-				const loaded = await persistence.load(m.id);
-				const afterRepair = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id)?.revision;
-				globalExpect(afterRepair).not.toBe(beforeRepair);
-				globalExpect(loaded.events.map((e) => e.type)).toEqual([
-					"turn/start",
-					"user/message",
-					"step/start",
-					"assistant/message",
-					"step/end",
-					"turn/end",
-					"turn/start",
-					"step/start",
-					"step/end",
-					"turn/end"
-				]);
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					8,
-					9
-				]);
-				const last = loaded.events.at(-1);
-				globalExpect(last.type === "turn/end" && last.data.reason).toEqual({ kind: "interrupted" });
-				await persistence.append(m.id, [{
-					type: "turn/start",
-					seq: SessionSeq(10),
-					time: 9,
-					data: { turn: 3 }
-				}, {
-					type: "turn/end",
-					seq: SessionSeq(11),
-					time: 10,
-					data: {
-						turn: 3,
-						reason: { kind: "completed" }
-					}
-				}]);
-				const reloaded = await persistence.load(m.id);
-				globalExpect(reloaded.events.map((e) => e.seq)).toEqual([
+				const first = await persistence.create(meta("dup-pending"));
+				await globalExpect(persistence.create(meta("dup-pending"))).rejects.toBeInstanceOf(SessionAlreadyExistsError);
+				await first.close();
+				await (await persistence.create(meta("dup-pending"))).close();
+			} finally {
+				await dispose();
+			}
+		});
+		it("concurrent duplicate creates: one wins, the loser rejects SessionAlreadyExistsError", async () => {
+			const { persistence, dispose } = await make();
+			try {
+				const m = meta("dup-race");
+				const results = await Promise.allSettled([persistence.create(m), persistence.create(m)]);
+				const winners = results.filter((r) => r.status === "fulfilled");
+				const losers = results.filter((r) => r.status === "rejected");
+				globalExpect(winners).toHaveLength(1);
+				globalExpect(losers).toHaveLength(1);
+				globalExpect(losers[0].reason).toBeInstanceOf(SessionAlreadyExistsError);
+				await winners[0].value.close();
+			} finally {
+				await dispose();
+			}
+		});
+		it("duplicate create rejects against a materialized artifact seen by a fresh instance", async () => {
+			const backend = await make();
+			try {
+				if (backend.reopen === void 0) return;
+				const m = meta("dup-stored", "/work");
+				const handle = await backend.persistence.create(m);
+				await handle.append(oneTurnLog());
+				await handle.close();
+				const reopened = await backend.reopen();
+				try {
+					await globalExpect(reopened.persistence.create(meta("dup-stored", "/work"))).rejects.toBeInstanceOf(SessionAlreadyExistsError);
+				} finally {
+					await reopened.dispose();
+				}
+			} finally {
+				await backend.dispose();
+			}
+		});
+		it("open of an absent session rejects with SessionPersistenceNotFoundError for both accesses", async () => {
+			const { persistence, dispose } = await make();
+			try {
+				await globalExpect(persistence.open(SessionId("absent"), "read")).rejects.toBeInstanceOf(SessionPersistenceNotFoundError);
+				await globalExpect(persistence.open(SessionId("absent"), "write")).rejects.toBeInstanceOf(SessionPersistenceNotFoundError);
+			} finally {
+				await dispose();
+			}
+		});
+		it("write ownership is single-holder per instance and released by close", async () => {
+			const { persistence, dispose } = await make();
+			try {
+				const m = meta("owned");
+				const creator = await persistence.create(m);
+				await globalExpect(persistence.open(m.id, "write")).rejects.toBeInstanceOf(SessionAlreadyOwnedError);
+				await creator.append(oneTurnLog());
+				await globalExpect(persistence.open(m.id, "write")).rejects.toBeInstanceOf(SessionAlreadyOwnedError);
+				await creator.close();
+				const writer = await persistence.open(m.id, "write");
+				await writer.append(secondTurn());
+				globalExpect((await writer.read()).events.map((e) => e.seq)).toEqual([
 					0,
 					1,
 					2,
@@ -13895,331 +13944,371 @@ function runPersistenceContract(name, make) {
 					4,
 					5,
 					6,
-					7,
-					8,
-					9,
-					10,
-					11
+					7
 				]);
+				await writer.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("crash recovery: an unstarted assistant tool request gets a retryable synthetic result", async () => {
+		it("a read handle refuses append and flush with SessionReadOnlyError", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("interrupted-toolcall");
-				await persistence.create(m);
-				await persistence.append(m.id, oneTurnLog());
-				await persistence.append(m.id, [
-					{
-						type: "turn/start",
-						seq: SessionSeq(6),
-						time: 7,
-						data: { turn: 2 }
-					},
-					{
-						type: "step/start",
-						seq: SessionSeq(7),
-						time: 8,
-						data: {
-							turn: 2,
-							step: 1
-						}
-					},
-					{
-						type: "assistant/message",
-						seq: SessionSeq(8),
-						time: 9,
-						data: {
-							turn: 2,
-							step: 1,
-							message: createMessage({
-								role: "assistant",
-								content: [{
-									type: "tool-call",
-									id: ToolCallId("call-x"),
-									name: "bash",
-									arguments: "{}"
-								}],
-								source: {
-									kind: "model",
-									provider: "mock",
-									model: "mock"
-								}
-							})
-						},
-						surfaceOp: "append"
-					}
-				]);
-				const loaded = await persistence.load(m.id);
-				globalExpect(loaded.events.map((e) => e.type)).toEqual([
-					"turn/start",
-					"user/message",
-					"step/start",
-					"assistant/message",
-					"step/end",
-					"turn/end",
-					"turn/start",
-					"step/start",
-					"assistant/message",
-					"tool/result",
-					"step/end",
-					"turn/end"
-				]);
-				const synthetic = loaded.events.find((e) => e.type === "tool/result");
-				globalExpect(synthetic?.type === "tool/result" && synthetic.data).toMatchObject({
-					message: {
-						source: {
-							kind: "tool",
-							callId: ToolCallId("call-x")
-						},
-						content: [{
-							type: "tool-result",
-							toolCallId: ToolCallId("call-x"),
-							isError: true
-						}]
-					},
-					error: { code: TOOL_NOT_STARTED }
-				});
-				const call = loaded.events.findLast((e) => e.type === "assistant/message");
-				const callId = call?.type === "assistant/message" && call.data.message.content.find((b) => b.type === "tool-call");
-				globalExpect(callId && callId.type === "tool-call" && callId.id).toBe(ToolCallId("call-x"));
+				const m = meta("read-only");
+				const writer = await persistence.create(m);
+				await writer.append(oneTurnLog());
+				await writer.close();
+				const reader = await persistence.open(m.id, "read");
+				globalExpect(reader.access).toBe("read");
+				await globalExpect(reader.append(secondTurn())).rejects.toBeInstanceOf(SessionReadOnlyError);
+				await globalExpect(reader.flush()).rejects.toBeInstanceOf(SessionReadOnlyError);
+				globalExpect((await reader.read()).events).toEqual(oneTurnLog());
+				await reader.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("crash recovery: a recorded tool call with no result tells the model to assess retry risk", async () => {
+		it("operations on a closed handle reject; close is idempotent; asyncDispose releases ownership", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("unknown-tool-outcome");
-				await persistence.create(m);
-				await persistence.append(m.id, [
-					{
-						type: "turn/start",
-						seq: SessionSeq(0),
-						time: 1,
-						data: { turn: 1 }
-					},
-					{
-						type: "step/start",
-						seq: SessionSeq(1),
-						time: 2,
-						data: {
-							turn: 1,
-							step: 1
-						}
-					},
-					{
-						type: "assistant/message",
-						seq: SessionSeq(2),
-						time: 3,
-						data: {
-							turn: 1,
-							step: 1,
-							message: createMessage({
-								role: "assistant",
-								content: [{
-									type: "tool-call",
-									id: ToolCallId("call-risk"),
-									name: "write",
-									arguments: "{}"
-								}],
-								source: {
-									kind: "model",
-									provider: "mock",
-									model: "mock"
-								}
-							})
-						},
-						surfaceOp: "append"
-					},
-					{
-						type: "tool/call",
-						seq: SessionSeq(3),
-						time: 4,
-						data: {
-							turn: 1,
-							step: 1,
-							callId: ToolCallId("call-risk"),
-							name: "write",
-							arguments: "{}"
-						}
-					}
-				]);
-				const loaded = await persistence.load(m.id);
-				const synthetic = loaded.events.find((e) => e.type === "tool/result");
-				globalExpect(synthetic?.type === "tool/result" && synthetic.data.error).toEqual({
-					name: "ToolOutcomeUnknownError",
-					code: TOOL_OUTCOME_UNKNOWN
-				});
-				if (synthetic?.type !== "tool/result" || synthetic.data.message.content[0].content[0]?.type !== "text") throw new Error("expected a text tool result");
-				globalExpect(synthetic.data.message.content[0].content[0].text).toContain("retry only if the operation is read-only or idempotent");
-				globalExpect(synthetic.data.message.content[0].content[0].text).toContain("if it may have side effects, first verify external state or ask the user");
-				const resumedResult = Session.create(m.id, loaded.events, loaded.meta, loaded.inheritedEventCount).deriveMessages().find((message) => message.content.some((block) => block.type === "tool-result"));
-				globalExpect(resumedResult?.content[0]).toMatchObject({
-					type: "tool-result",
-					toolCallId: ToolCallId("call-risk"),
-					isError: true
-				});
+				const m = meta("closed");
+				const handle = await persistence.create(m);
+				await handle.append(oneTurnLog());
+				await handle.close();
+				await handle.close();
+				await globalExpect(handle.read()).rejects.toBeInstanceOf(SessionHandleClosedError);
+				await globalExpect(handle.append(secondTurn())).rejects.toBeInstanceOf(SessionHandleClosedError);
+				await globalExpect(handle.flush()).rejects.toBeInstanceOf(SessionHandleClosedError);
+				{
+					await using writer = await persistence.open(m.id, "write");
+					await writer.append(secondTurn());
+				}
+				await (await persistence.open(m.id, "write")).close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("list() excludes a created-but-never-appended (zero-event) session", async () => {
-			const { persistence, dispose } = await make();
+		it("service-level flush materializes every active write handle and counts a closing one as flushed", async () => {
+			const backend = await make();
+			try {
+				const materialized = await backend.persistence.create(meta("flush-all"));
+				const closing = (await backend.persistence.create(meta("flush-all-closing"))).close();
+				await backend.persistence.flush();
+				await closing;
+				if (backend.reopen !== void 0) {
+					const reopened = await backend.reopen();
+					try {
+						globalExpect(await reopened.persistence.stat(SessionId("flush-all"))).toBeDefined();
+						globalExpect(await reopened.persistence.stat(SessionId("flush-all-closing"))).toBeUndefined();
+					} finally {
+						await reopened.dispose();
+					}
+				}
+				await materialized.close();
+			} finally {
+				await backend.dispose();
+			}
+		});
+		it("a created-but-unappended session is visible to this instance and invisible to a fresh one", async () => {
+			const backend = await make();
 			try {
-				await persistence.create(meta("empty"));
-				globalExpect((await persistence.list()).map((m) => m.id)).not.toContain(SessionId("empty"));
-				globalExpect((await persistence.listSnapshots()).map((snapshot) => snapshot.header.id)).not.toContain(SessionId("empty"));
+				const m = meta("lazy", "/work");
+				const creator = await backend.persistence.create(m);
+				globalExpect((await creator.read()).events).toEqual([]);
+				const snapshot = await backend.persistence.stat(m.id);
+				globalExpect(snapshot?.header).toMatchObject(m);
+				globalExpect((await backend.persistence.list()).map((s) => s.header.id)).toContain(m.id);
+				const reader = await backend.persistence.open(m.id, "read");
+				globalExpect((await reader.read()).events).toEqual([]);
+				await reader.close();
+				if (backend.reopen !== void 0) {
+					const reopened = await backend.reopen();
+					try {
+						globalExpect(await reopened.persistence.stat(m.id)).toBeUndefined();
+						globalExpect((await reopened.persistence.list()).map((s) => s.header.id)).not.toContain(m.id);
+						await globalExpect(reopened.persistence.open(m.id, "read")).rejects.toBeInstanceOf(SessionPersistenceNotFoundError);
+					} finally {
+						await reopened.dispose();
+					}
+				}
+				await creator.close();
 			} finally {
-				await dispose();
+				await backend.dispose();
 			}
 		});
-		it("rejects pre-aborted observation reads with the exact cancellation reason", async () => {
+		it("close without an append erases the created session from this instance", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const reason = /* @__PURE__ */ new Error("persistence observation cancelled");
-				const controller = new AbortController();
-				await globalExpect(persistence.listSnapshots(controller.signal)).resolves.toEqual([]);
-				controller.abort(reason);
-				await globalExpect(persistence.list(controller.signal)).rejects.toBe(reason);
-				await globalExpect(persistence.listSnapshots(controller.signal)).rejects.toBe(reason);
-				await globalExpect(persistence.inspect(SessionId("cancelled-inspect"), controller.signal)).rejects.toBe(reason);
-				await globalExpect(persistence.readFrom(SessionId("cancelled-read-from"), SessionLogOffset(0), controller.signal)).rejects.toBe(reason);
+				const m = meta("never-was");
+				await (await persistence.create(m)).close();
+				globalExpect(await persistence.stat(m.id)).toBeUndefined();
+				globalExpect((await persistence.list()).map((s) => s.header.id)).not.toContain(m.id);
+				await globalExpect(persistence.open(m.id, "read")).rejects.toBeInstanceOf(SessionPersistenceNotFoundError);
 			} finally {
 				await dispose();
 			}
 		});
-		it("readFrom returns exactly the stored suffix from the requested seq, without mutating the log", async () => {
-			const { persistence, dispose } = await make();
+		it("flush materializes an empty session durably for a fresh instance", async () => {
+			const backend = await make();
 			try {
-				const m = meta("read-from", "/work");
-				const log = oneTurnLog();
-				await persistence.create(m);
-				await persistence.append(m.id, log);
-				const whole = await persistence.readFrom(m.id, SessionLogOffset(0));
-				globalExpect(whole.meta).toMatchObject({
-					id: m.id,
-					cwd: "/work"
-				});
-				globalExpect(whole.events).toEqual(log);
-				const suffix = await persistence.readFrom(m.id, SessionLogOffset(3));
-				globalExpect(suffix.events).toEqual(log.slice(3));
-				globalExpect(suffix.events[0]?.seq).toBe(3);
-				await globalExpect(persistence.readFrom(m.id, SessionLogOffset(log.length))).resolves.toMatchObject({ events: [] });
-				await globalExpect(persistence.readFrom(m.id, SessionLogOffset(log.length + 100))).resolves.toMatchObject({ events: [] });
-				await persistence.append(m.id, [{
-					type: "turn/start",
-					seq: SessionSeq(6),
-					time: 7,
-					data: { turn: 2 }
-				}]);
-				const tail = await persistence.readFrom(m.id, SessionLogOffset(6));
-				globalExpect(tail.events.map((event) => event.type)).toEqual(["turn/start"]);
-				await globalExpect(persistence.readFrom(SessionId("absent-read-from"), SessionLogOffset(0))).rejects.toThrow("not found");
-				await globalExpect(persistence.readFrom(m.id, -1)).rejects.toThrow("non-negative safe integer");
-				await globalExpect(persistence.readFrom(m.id, 1.5)).rejects.toThrow("non-negative safe integer");
+				if (backend.reopen === void 0) return;
+				const m = meta("durable-empty", "/work");
+				const creator = await backend.persistence.create(m);
+				await creator.flush();
+				await creator.close();
+				const reopened = await backend.reopen();
+				try {
+					globalExpect((await reopened.persistence.list()).map((s) => s.header.id)).toContain(m.id);
+					globalExpect((await reopened.persistence.stat(m.id))?.header).toMatchObject(m);
+					const reader = await reopened.persistence.open(m.id, "read");
+					globalExpect((await reader.read()).events).toEqual([]);
+					await reader.close();
+				} finally {
+					await reopened.dispose();
+				}
 			} finally {
-				await dispose();
+				await backend.dispose();
 			}
 		});
-		it("lists stable lightweight revisions that change after an append", async () => {
+		it("freshness: reads started after an append resolves observe that prefix on any handle", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("s2");
-				await persistence.create(m);
-				await persistence.append(m.id, oneTurnLog());
-				globalExpect((await persistence.list()).map((x) => x.id)).toContain(m.id);
-				const first = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id);
-				const repeated = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id);
-				globalExpect(first).toBeDefined();
-				globalExpect(repeated?.revision).toBe(first?.revision);
-				await persistence.append(m.id, [{
-					type: "turn/start",
-					seq: SessionSeq(6),
-					time: 7,
-					data: { turn: 2 }
-				}]);
-				const changed = (await persistence.listSnapshots()).find((snapshot) => snapshot.header.id === m.id);
-				globalExpect(changed?.revision).not.toBe(first?.revision);
+				const m = meta("fresh");
+				const writer = await persistence.create(m);
+				await writer.append(oneTurnLog());
+				const before = await persistence.open(m.id, "read");
+				globalExpect((await before.read()).events).toEqual(oneTurnLog());
+				await writer.append(secondTurn());
+				globalExpect((await before.read()).events.map((e) => e.seq)).toEqual([
+					0,
+					1,
+					2,
+					3,
+					4,
+					5,
+					6,
+					7
+				]);
+				const after = await persistence.open(m.id, "read");
+				globalExpect((await after.read()).events.map((e) => e.seq)).toEqual([
+					0,
+					1,
+					2,
+					3,
+					4,
+					5,
+					6,
+					7
+				]);
+				await before.close();
+				await after.close();
+				await writer.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("append rejects a batch whose first seq does not match the stored next-seq", async () => {
+		it("a fresh instance continues the stored log at the committed next-seq", async () => {
+			const backend = await make();
+			try {
+				if (backend.reopen === void 0) return;
+				const m = meta("continue", "/work");
+				const creator = await backend.persistence.create(m);
+				await creator.append(oneTurnLog());
+				await creator.close();
+				const reopened = await backend.reopen();
+				try {
+					const writer = await reopened.persistence.open(m.id, "write");
+					await writer.append(secondTurn());
+					globalExpect((await writer.read()).events.map((e) => e.seq)).toEqual([
+						0,
+						1,
+						2,
+						3,
+						4,
+						5,
+						6,
+						7
+					]);
+					await writer.close();
+				} finally {
+					await reopened.dispose();
+				}
+			} finally {
+				await backend.dispose();
+			}
+		});
+		it("append rejects a batch that does not contiguously continue the log, naming the expected seq", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("s3");
-				await persistence.create(m);
-				await persistence.append(m.id, oneTurnLog());
-				const restated = oneTurnLog();
-				await globalExpect(persistence.append(m.id, restated)).rejects.toThrow();
+				const m = meta("contiguity");
+				const handle = await persistence.create(m);
+				await handle.append(oneTurnLog());
+				await globalExpect(handle.append(oneTurnLog())).rejects.toThrow(/expected 6/);
+				const gapped = [{
+					type: "turn/start",
+					seq: SessionSeq(6),
+					time: 9,
+					data: { turn: 2 }
+				}, {
+					type: "turn/end",
+					seq: SessionSeq(8),
+					time: 10,
+					data: {
+						turn: 2,
+						reason: { kind: "completed" }
+					}
+				}];
+				await globalExpect(handle.append(gapped)).rejects.toThrow(/expected 7/);
+				globalExpect((await handle.read()).events.map((e) => e.seq)).toEqual([
+					0,
+					1,
+					2,
+					3,
+					4,
+					5
+				]);
+				await handle.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("append rejects a mid-batch seq gap", async () => {
+		it("append rejects non-JSON-serializable event data without storing anything", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const m = meta("s4");
-				await persistence.create(m);
-				const gapped = [{
+				const m = meta("non-json");
+				const handle = await persistence.create(m);
+				const bad = (extra) => [{
 					type: "turn/start",
 					seq: SessionSeq(0),
 					time: 1,
-					data: { turn: 1 }
-				}, {
-					type: "step/start",
-					seq: SessionSeq(2),
-					time: 2,
 					data: {
 						turn: 1,
-						step: 1
+						extra
 					}
 				}];
-				await globalExpect(persistence.append(m.id, gapped)).rejects.toThrow();
+				await globalExpect(handle.append(bad(1n))).rejects.toThrow(TypeError);
+				await globalExpect(handle.append(bad(1n))).rejects.toThrow(/losslessly JSON-serializable/);
+				await globalExpect(handle.append(bad(void 0))).rejects.toThrow(/losslessly JSON-serializable/);
+				await handle.append(oneTurnLog());
+				globalExpect((await handle.read()).events).toEqual(oneTurnLog());
+				await handle.close();
 			} finally {
 				await dispose();
 			}
 		});
-		it("append rejects non-JSON-serializable event data, naming the event type", async () => {
+		it("vocabulary fail-closed: an unknown event type refuses append and stored reads", async () => {
 			const { persistence, dispose } = await make();
 			try {
-				const cyclic = {
-					type: "text",
-					text: "x"
-				};
-				cyclic["self"] = cyclic;
-				const badValues = [
-					1n,
-					void 0,
-					Infinity,
-					() => 0,
-					Symbol("s"),
-					/* @__PURE__ */ new Map(),
-					cyclic
-				];
-				for (const [i, bad] of badValues.entries()) {
-					const mi = meta(`s5-${i}`);
-					await persistence.create(mi);
-					const events = [{
-						type: "user/message",
-						seq: SessionSeq(0),
-						time: 1,
+				const m = meta("foreign-vocabulary");
+				const handle = await persistence.create(m);
+				await handle.append(oneTurnLog());
+				await globalExpect(handle.append([{
+					type: "mystery/event",
+					seq: SessionSeq(6),
+					time: 7,
+					data: { payload: true }
+				}])).rejects.toBeInstanceOf(SessionFormatUnsupportedError);
+				await handle.close();
+				const reader = await persistence.open(m.id, "read");
+				try {
+					const { events } = await reader.read();
+					globalExpect(events).toHaveLength(6);
+				} finally {
+					await reader.close();
+				}
+				const writer = await persistence.open(m.id, "write");
+				try {
+					await writer.append([{
+						type: "turn/end",
+						seq: SessionSeq(6),
+						time: 7,
 						data: {
-							id: MessageId(`invalid-json-${i}`),
-							role: "user",
-							content: [{
-								type: "text",
-								text: "x"
-							}],
-							source: { kind: "user" },
-							extra: bad
+							turn: 2,
+							reason: { kind: "completed" }
 						}
-					}];
-					await globalExpect(persistence.append(mi.id, events)).rejects.toThrow(/losslessly JSON-serializable/);
+					}]);
+				} finally {
+					await writer.close();
+				}
+			} finally {
+				await dispose();
+			}
+		});
+		it("a torn physical tail is never served and is durably truncated by the write path", async () => {
+			const backend = await make();
+			try {
+				if (backend.reopen === void 0 || backend.corruptTail === void 0) return;
+				const m = meta("torn", "/work");
+				const creator = await backend.persistence.create(m);
+				await creator.append(oneTurnLog());
+				await creator.close();
+				await backend.corruptTail(m.id, m.cwd);
+				const readerInstance = await backend.reopen();
+				try {
+					const reader = await readerInstance.persistence.open(m.id, "read");
+					globalExpect((await reader.read()).events).toEqual(oneTurnLog());
+					await reader.close();
+					const writer = await readerInstance.persistence.open(m.id, "write");
+					await writer.append(secondTurn());
+					globalExpect((await writer.read()).events.map((e) => e.seq)).toEqual([
+						0,
+						1,
+						2,
+						3,
+						4,
+						5,
+						6,
+						7
+					]);
+					await writer.close();
+				} finally {
+					await readerInstance.dispose();
+				}
+				const verifyInstance = await backend.reopen();
+				try {
+					const verify = await verifyInstance.persistence.open(m.id, "read");
+					globalExpect((await verify.read()).events.map((e) => e.seq)).toEqual([
+						0,
+						1,
+						2,
+						3,
+						4,
+						5,
+						6,
+						7
+					]);
+					await verify.close();
+				} finally {
+					await verifyInstance.dispose();
 				}
+			} finally {
+				await backend.dispose();
+			}
+		});
+		it("stat and list agree on stable revisions that change after an append", async () => {
+			const { persistence, dispose } = await make();
+			try {
+				const m = meta("revisions", "/work");
+				const writer = await persistence.create(m);
+				await writer.append(oneTurnLog());
+				const statFirst = await persistence.stat(m.id);
+				const statAgain = await persistence.stat(m.id);
+				const listFirst = (await persistence.list()).find((s) => s.header.id === m.id);
+				globalExpect(statFirst).toBeDefined();
+				globalExpect(statAgain?.revision).toBe(statFirst?.revision);
+				globalExpect(listFirst?.revision).toBe(statFirst?.revision);
+				await writer.append(secondTurn());
+				const statChanged = await persistence.stat(m.id);
+				globalExpect(statChanged?.revision).not.toBe(statFirst?.revision);
+				const listChanged = (await persistence.list()).find((s) => s.header.id === m.id);
+				globalExpect(listChanged?.revision).toBe(statChanged?.revision);
+				const reader = await persistence.open(m.id, "read");
+				globalExpect(statChanged?.header).toEqual(reader.header);
+				globalExpect(listChanged?.header).toEqual(reader.header);
+				globalExpect(statChanged?.header).toMatchObject(m);
+				await reader.close();
+				await writer.close();
+				globalExpect(await persistence.stat(SessionId("absent-stat"))).toBeUndefined();
 			} finally {
 				await dispose();
 			}
@@ -14229,398 +14318,16 @@ function runPersistenceContract(name, make) {
 //#endregion
 //#region src/testing/coordinator-contract.ts
 const WORK = "/w";
-const OTHER = "/other";
 function send(session, events) {
 	appendLog(session, events);
 }
-function legacyMessageLog() {
-	return [
-		{
-			type: "turn/start",
-			seq: SessionSeq(0),
-			time: 1,
-			data: { turn: 1 }
-		},
-		{
-			type: "user/message",
-			seq: SessionSeq(1),
-			time: 2,
-			data: {
-				content: [{
-					type: "text",
-					text: "hi"
-				}],
-				source: { kind: "user" }
-			},
-			surfaceOp: "append"
-		},
-		{
-			type: "step/start",
-			seq: SessionSeq(2),
-			time: 3,
-			data: {
-				turn: 1,
-				step: 1
-			}
-		},
-		{
-			type: "assistant/message",
-			seq: SessionSeq(3),
-			time: 4,
-			data: {
-				turn: 1,
-				step: 1,
-				content: [{
-					type: "tool-call",
-					id: "call-1",
-					name: "read",
-					arguments: "{}"
-				}],
-				provenance: {
-					provider: "mock",
-					model: "mock"
-				}
-			},
-			surfaceOp: "append"
-		},
-		{
-			type: "tool/call",
-			seq: SessionSeq(4),
-			time: 5,
-			data: {
-				turn: 1,
-				step: 1,
-				callId: "call-1",
-				name: "read",
-				arguments: "{}"
-			}
-		},
-		{
-			type: "tool/result",
-			seq: SessionSeq(5),
-			time: 6,
-			data: {
-				turn: 1,
-				step: 1,
-				callId: "call-1",
-				content: [{
-					type: "text",
-					text: "full result"
-				}],
-				isError: false
-			},
-			sourceEventSeqs: [4],
-			surfaceOp: "append"
-		},
-		{
-			type: "tool/result",
-			seq: SessionSeq(6),
-			time: 8,
-			data: {
-				turn: 1,
-				step: 1,
-				callId: "call-1",
-				content: [{
-					type: "text",
-					text: "pruned"
-				}],
-				isError: false
-			},
-			sourceEventSeqs: [5],
-			surfaceOp: {
-				op: "replace",
-				start: 5,
-				end: 5
-			}
-		},
-		{
-			type: "step/end",
-			seq: SessionSeq(7),
-			time: 9,
-			data: {
-				turn: 1,
-				step: 1
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(8),
-			time: 10,
-			data: {
-				turn: 1,
-				reason: { kind: "completed" }
-			}
-		}
-	];
-}
-function preReactLoopLog() {
-	const prompt = createUserMessage({
-		content: [{
-			type: "text",
-			text: "old prompt"
-		}],
-		source: { kind: "user" }
-	});
-	const steering = createUserMessage({
-		content: [{
-			type: "text",
-			text: "old steering"
-		}],
-		source: { kind: "user" }
-	});
-	return [
-		{
-			type: "turn/start",
-			seq: SessionSeq(0),
-			time: 1,
-			data: {
-				turn: 1,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "user/message",
-			seq: SessionSeq(1),
-			time: 2,
-			data: prompt,
-			surfaceOp: "append"
-		},
-		{
-			type: "step/start",
-			seq: SessionSeq(2),
-			time: 3,
-			data: {
-				turn: 1,
-				step: 1
-			}
-		},
-		{
-			type: "steering/message",
-			seq: SessionSeq(3),
-			time: 4,
-			data: {
-				turn: 1,
-				message: steering
-			},
-			surfaceOp: "append"
-		},
-		{
-			type: "step/end",
-			seq: SessionSeq(4),
-			time: 5,
-			data: {
-				turn: 1,
-				step: 1
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(5),
-			time: 6,
-			data: {
-				turn: 1,
-				reason: { kind: "completed" }
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(6),
-			time: 7,
-			data: {
-				turn: 2,
-				trigger: { kind: "retry" }
-			}
-		},
-		{
-			type: "step/start",
-			seq: SessionSeq(7),
-			time: 8,
-			data: {
-				turn: 2,
-				step: 1
-			}
-		},
-		{
-			type: "step/end",
-			seq: SessionSeq(8),
-			time: 9,
-			data: {
-				turn: 2,
-				step: 1
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(9),
-			time: 10,
-			data: {
-				turn: 2,
-				reason: {
-					kind: "error",
-					step: 1,
-					failure: {
-						message: "old provider failure",
-						code: "SERVER"
-					}
-				}
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(10),
-			time: 11,
-			data: {
-				turn: 3,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(11),
-			time: 12,
-			data: {
-				turn: 3,
-				reason: { kind: "aborted" }
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(12),
-			time: 13,
-			data: {
-				turn: 4,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(13),
-			time: 14,
-			data: {
-				turn: 4,
-				reason: { kind: "disposed" }
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(14),
-			time: 15,
-			data: {
-				turn: 5,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "step/start",
-			seq: SessionSeq(15),
-			time: 16,
-			data: {
-				turn: 5,
-				step: 1
-			}
-		},
-		{
-			type: "step/end",
-			seq: SessionSeq(16),
-			time: 17,
-			data: {
-				turn: 5,
-				step: 1
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(17),
-			time: 18,
-			data: {
-				turn: 5,
-				reason: {
-					kind: "error",
-					step: 1,
-					message: "old thrown value"
-				}
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(18),
-			time: 19,
-			data: {
-				turn: 6,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(19),
-			time: 20,
-			data: {
-				turn: 6,
-				reason: {
-					kind: "error",
-					step: 0,
-					failure: {
-						message: "old detailed provider failure",
-						code: "RATE_LIMIT",
-						status: 429,
-						providerRetryAfterMs: 1e3,
-						requestId: "request-1"
-					}
-				}
-			}
-		},
-		{
-			type: "turn/start",
-			seq: SessionSeq(20),
-			time: 21,
-			data: {
-				turn: 7,
-				trigger: {
-					kind: "message",
-					source: { kind: "user" }
-				}
-			}
-		},
-		{
-			type: "turn/end",
-			seq: SessionSeq(21),
-			time: 22,
-			data: {
-				turn: 7,
-				reason: {
-					kind: "error",
-					step: 0,
-					message: "old coded error",
-					code: "CODED"
-				}
-			}
-		}
-	];
-}
-async function liveSessionInFiber(ctx, id, cwd) {
-	let session;
-	await ctx.plugin(Object.assign((inner) => {
-		session = inner.sessions.create(SessionId(id), cwd !== void 0 ? { meta: { cwd } } : void 0);
-	}, { inject: ["sessions"] }));
-	return session;
-}
+/**
+* RDB 特有行为契约：live 会话驱动持久化、seed 边界、fork/resume、HMR
+* dispose drain、冲突拒绝、torn-tail。coordinator 内部状态（ownerless /
+* per-id chain / legacy 迁移）已由新版 handle 模型承担，不再单独测试。
+*/
 function runCoordinatorContract(name, makeFixture) {
-	describe(`PersistenceCoordinator orchestration: ${name}`, () => {
+	describe(`SessionPersistenceRdb orchestration: ${name}`, () => {
 		async function freshCtx(fix) {
 			const ctx = new Context();
 			await ctx.plugin(SessionStore);
@@ -14629,6 +14336,18 @@ function runCoordinatorContract(name, makeFixture) {
 				fiber: await fix.mount(ctx)
 			};
 		}
+		async function readAll(ctx, id) {
+			const handle = await ctx.sessionPersistence.open(id, "read");
+			try {
+				const { events } = await handle.read();
+				return {
+					meta: handle.header,
+					events
+				};
+			} finally {
+				await handle.close();
+			}
+		}
 		it("persists a live session driven through the store, surviving reload", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
@@ -14636,7 +14355,7 @@ function runCoordinatorContract(name, makeFixture) {
 				const session = ctx.sessions.create(SessionId("live"), { meta: { cwd: WORK } });
 				send(session, oneTurnLog());
 				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("live"));
+				const loaded = await readAll(ctx, SessionId("live"));
 				globalExpect(loaded.events).toHaveLength(6);
 				globalExpect(loaded.meta.cwd).toBe(WORK);
 			} finally {
@@ -14644,106 +14363,31 @@ function runCoordinatorContract(name, makeFixture) {
 				await fix.cleanup();
 			}
 		});
-		it("rejects crash-repair load while a live session owns the persisted prefix", async () => {
+		it("round-trips the seed boundary (inheritedEventCount) through persistence", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
-			let session;
-			const sessionFiber = await ctx.plugin(Object.assign((inner) => {
-				session = inner.sessions.create(SessionId("live-load"), { meta: { cwd: WORK } });
-			}, { inject: ["sessions"] }));
 			try {
-				session.append("turn/start", { turn: 1 });
-				await ctx.sessions.flush(session);
-				await globalExpect(ctx.sessionPersistence.load(session.id)).rejects.toThrow(`cannot load session "${session.id}" while its live turn is open`);
-				send(session, oneTurnLog().slice(1));
+				let session;
+				const sessionFiber = await ctx.plugin(Object.assign((inner) => {
+					session = inner.sessions.create(SessionId("forked-child"), {
+						seed: oneTurnLog().slice(0, 3),
+						meta: {
+							cwd: WORK,
+							isSeeded: true
+						},
+						inheritedEventCount: SessionLogOffset(3)
+					});
+				}, { inject: ["sessions"] }));
+				send(session, oneTurnLog().slice(3));
 				await ctx.sessions.flush(session);
 				await sessionFiber.dispose();
-				await vi.waitFor(async () => {
-					const loaded = await ctx.sessionPersistence.load(session.id);
-					globalExpect(loaded.events.map((event) => event.type)).toEqual(oneTurnLog().map((event) => event.type));
-					globalExpect(loaded.events.at(-1)).toMatchObject({
-						type: "turn/end",
-						data: { reason: { kind: "completed" } }
-					});
-				});
-			} finally {
-				await sessionFiber.dispose();
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("rechecks live ownership after a cold load enters the per-id chain", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const id = SessionId("queued-load-live-race");
-				const header = meta(id, WORK);
-				const start = {
-					type: "turn/start",
-					seq: SessionSeq(0),
-					time: 1,
-					data: { turn: 1 }
-				};
-				await ctx.sessionPersistence.create(header);
-				await ctx.sessionPersistence.append(id, [start]);
-				const loading = ctx.sessionPersistence.load(id);
-				const live = ctx.sessions.create(id, {
-					seed: [start],
-					meta: header
-				});
-				await globalExpect(loading).rejects.toThrow(/live turn is open/);
-				live.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(live);
-				const loaded = await ctx.sessionPersistence.load(id);
-				globalExpect(loaded.events.map((event) => event.type)).toEqual([
-					"turn/start",
-					"session/end-seed",
-					"turn/end"
-				]);
-				globalExpect(loaded.events.at(-1)).toMatchObject({
-					type: "turn/end",
-					data: { reason: { kind: "completed" } }
-				});
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("does not load an unmaterialized empty live session", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const session = ctx.sessions.create(SessionId("empty-live"), { meta: { cwd: WORK } });
-				await globalExpect(ctx.sessionPersistence.load(session.id)).rejects.toThrow(/not found/);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("round-trips the seed boundary (inheritedEventCount) through persistence", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				let session;
-				const sessionFiber = await ctx.plugin(Object.assign((inner) => {
-					session = inner.sessions.create(SessionId("forked-child"), {
-						seed: oneTurnLog().slice(0, 3),
-						meta: {
-							cwd: WORK,
-							isSeeded: true
-						},
-						inheritedEventCount: SessionLogOffset(3)
-					});
-				}, { inject: ["sessions"] }));
-				send(session, oneTurnLog().slice(3));
-				await ctx.sessions.flush(session);
-				await sessionFiber.dispose();
-				const loaded = await ctx.sessionPersistence.load(SessionId("forked-child"));
-				globalExpect(loaded.meta.isSeeded).toBe(true);
-				globalExpect(loaded.inheritedEventCount).toBe(3);
+				const handle = await ctx.sessionPersistence.open(SessionId("forked-child"), "read");
+				try {
+					globalExpect(handle.header.isSeeded).toBe(true);
+					globalExpect(handle.inheritedEventCount).toBe(3);
+				} finally {
+					await handle.close();
+				}
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
@@ -14753,986 +14397,102 @@ function runCoordinatorContract(name, makeFixture) {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				let session;
-				const sessionFiber = await ctx.plugin(Object.assign((inner) => {
-					session = inner.sessions.create(SessionId("delegated-child"), { meta: {
-						cwd: WORK,
-						parentSession: SessionId("root"),
-						delegationDepth: 2
-					} });
-				}, { inject: ["sessions"] }));
-				send(session, oneTurnLog());
-				await ctx.parallel("session/flush", session);
-				await sessionFiber.dispose();
-				const loaded = await ctx.sessionPersistence.load(SessionId("delegated-child"));
-				globalExpect(loaded.meta.delegationDepth).toBe(2);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("source-frozen events cannot be mutated after buffering and persist unchanged", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const session = ctx.sessions.create(SessionId("mutate"), { meta: { cwd: WORK } });
-				session.append("turn/start", { turn: 1 });
-				const ev = session.append("user/message", createUserMessage({
-					content: [{
-						type: "text",
-						text: "original"
-					}],
-					source: { kind: "user" }
-				}), { surfaceOp: "append" });
-				globalExpect(() => {
-					ev.data.content[0].text = "HACKED";
-				}).toThrow(TypeError);
-				session.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(session);
-				const message = (await ctx.sessionPersistence.load(SessionId("mutate"))).events.find((event) => event.type === "user/message");
-				globalExpect(message?.type === "user/message" && message.data.content[0].text).toBe("original");
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("load and inspect return immutable identified-message snapshots", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const id = SessionId("immutable-read");
-				const session = ctx.sessions.create(id, { meta: { cwd: WORK } });
-				send(session, oneTurnLog());
-				await ctx.sessions.flush(session);
-				for (const snapshot of [await ctx.sessionPersistence.load(id), await ctx.sessionPersistence.inspect(id)]) {
-					const event = snapshot.events.find((candidate) => candidate.type === "user/message");
-					if (event?.type !== "user/message") throw new Error("fixture lacks user/message");
-					globalExpect(Object.isFrozen(event.data)).toBe(true);
-					globalExpect(Object.isFrozen(event.data.content)).toBe(true);
-					globalExpect(() => {
-						event.data.id = "rewritten";
-					}).toThrow(TypeError);
-					globalExpect(() => {
-						event.data.content[0].text = "rewritten";
-					}).toThrow(TypeError);
-				}
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("loads pre-identity message logs into resumable current sessions", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const id = SessionId("legacy-message-load");
-				await ctx.sessionPersistence.create(meta(id, WORK));
-				await ctx.sessionPersistence.append(id, legacyMessageLog());
-				for (const snapshot of [await ctx.sessionPersistence.inspect(id), await ctx.sessionPersistence.load(id)]) {
-					const messages = [];
-					for (const event of snapshot.events) if (event.type === "user/message") messages.push(event.data);
-					else if (event.type === "assistant/message" || event.type === "tool/result") messages.push(event.data.message);
-					globalExpect(messages.map((message) => message.id)).toEqual([
-						`legacy-message:${id}:1`,
-						`legacy-message:${id}:3`,
-						`legacy-message:${id}:5`,
-						`legacy-message:${id}:5`
-					]);
-					globalExpect(messages.every((message) => Object.isFrozen(message))).toBe(true);
-					const resumed = Session.create(id, snapshot.events, snapshot.meta, snapshot.inheritedEventCount);
-					globalExpect(resumed.deriveMessages().map((message) => message.id)).toEqual([
-						`legacy-message:${id}:1`,
-						`legacy-message:${id}:3`,
-						`legacy-message:${id}:5`
-					]);
-				}
-				const replacementSuffix = await ctx.sessionPersistence.readFrom(id, SessionLogOffset(6));
-				globalExpect(replacementSuffix.events[0]).toMatchObject({
-					type: "tool/result",
-					seq: SessionSeq(6),
-					data: { message: { id: `legacy-message:${id}:5` } }
-				});
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("loads pre-react-loop session logs into resumable current sessions", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const id = SessionId("pre-react-loop-load");
-				const log = preReactLoopLog();
-				const legacySteering = log[3];
-				await ctx.sessionPersistence.create(meta(id, WORK));
-				await ctx.sessionPersistence.append(id, log);
-				const snapshots = [
-					await ctx.sessionPersistence.inspect(id),
-					await ctx.sessionPersistence.readFrom(id, SessionLogOffset(0)),
-					await ctx.sessionPersistence.load(id)
-				];
-				for (const snapshot of snapshots) {
-					globalExpect(snapshot.events.some((event) => event.type === "steering/message")).toBe(false);
-					globalExpect(snapshot.events.filter((event) => event.type === "turn/start").map((event) => event.data)).toEqual([
-						{ turn: 1 },
-						{ turn: 2 },
-						{ turn: 3 },
-						{ turn: 4 },
-						{ turn: 5 },
-						{ turn: 6 },
-						{ turn: 7 }
-					]);
-					globalExpect(snapshot.events.filter((event) => event.type === "turn/end").map((event) => event.data)).toEqual([
-						{
-							turn: 1,
-							reason: { kind: "completed" }
-						},
-						{
-							turn: 2,
-							reason: {
-								kind: "error",
-								error: {
-									message: "old provider failure",
-									code: "SERVER"
-								}
-							}
-						},
-						{
-							turn: 3,
-							reason: {
-								kind: "aborted",
-								reason: { kind: "legacy" }
-							}
-						},
-						{
-							turn: 4,
-							reason: {
-								kind: "aborted",
-								reason: { kind: "disposed" }
-							}
-						},
-						{
-							turn: 5,
-							reason: {
-								kind: "error",
-								error: {
-									message: "old thrown value",
-									code: "UNKNOWN"
-								}
-							}
-						},
-						{
-							turn: 6,
-							reason: {
-								kind: "error",
-								error: {
-									message: "old detailed provider failure",
-									code: "RATE_LIMIT",
-									status: 429,
-									providerRetryAfterMs: 1e3,
-									requestId: "request-1"
-								}
-							}
-						},
-						{
-							turn: 7,
-							reason: {
-								kind: "error",
-								error: {
-									message: "old coded error",
-									code: "CODED"
-								}
-							}
-						}
-					]);
-					const resumed = Session.create(id, snapshot.events, snapshot.meta, snapshot.inheritedEventCount);
-					globalExpect(resumed.deriveMessages().map((message) => message.content)).toEqual([[{
-						type: "text",
-						text: "old prompt"
-					}], [{
-						type: "text",
-						text: "old steering"
-					}]]);
-				}
-				const suffix = await ctx.sessionPersistence.readFrom(id, SessionLogOffset(3));
-				globalExpect(suffix.events[0]).toMatchObject({
-					type: "user/message",
-					seq: SessionSeq(3),
-					data: { id: legacySteering.data.message.id }
-				});
-				globalExpect(suffix.events.filter((event) => event.type === "turn/end").every((event) => !Object.hasOwn(event.data, "step"))).toBe(true);
-				const flatId = SessionId("pre-react-loop-flat-steering");
-				await ctx.sessionPersistence.create(meta(flatId, WORK));
-				await ctx.sessionPersistence.append(flatId, [{
-					type: "steering/message",
-					seq: SessionSeq(0),
-					time: 1,
-					data: {
-						turn: 1,
-						content: [{
-							type: "text",
-							text: "flat steering"
-						}],
-						source: { kind: "user" }
-					},
-					surfaceOp: "append"
-				}]);
-				globalExpect((await ctx.sessionPersistence.inspect(flatId)).events[0]).toMatchObject({
-					type: "user/message",
-					data: {
-						id: `legacy-message:${flatId}:0`,
-						role: "user",
-						content: [{
-							type: "text",
-							text: "flat steering"
-						}]
-					}
-				});
-				const extendedId = SessionId("current-extended-turn-end");
-				await ctx.sessionPersistence.create(meta(extendedId, WORK));
-				await ctx.sessionPersistence.append(extendedId, [{
-					type: "turn/start",
-					seq: SessionSeq(0),
-					time: 1,
-					data: { turn: 1 }
-				}, {
-					type: "turn/end",
-					seq: SessionSeq(1),
-					time: 2,
-					data: {
-						turn: 1,
-						reason: { kind: "extension-reason" }
-					}
-				}]);
-				globalExpect((await ctx.sessionPersistence.inspect(extendedId)).events[1]).toMatchObject({
-					type: "turn/end",
-					data: { reason: { kind: "extension-reason" } }
-				});
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("rejects malformed persisted message events before returning them", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const id = SessionId("invalid-message-read");
-				await ctx.sessionPersistence.create(meta(id, WORK));
-				await ctx.sessionPersistence.append(id, [{
-					type: "user/message",
-					seq: SessionSeq(0),
-					time: 1,
-					surfaceOp: "append",
-					data: {
-						id: "wrong-role",
-						role: "assistant",
-						content: [{
-							type: "text",
-							text: "wrong"
-						}],
-						source: { kind: "user" }
-					}
-				}]);
-				await globalExpect(ctx.sessionPersistence.inspect(id)).rejects.toThrow("message must have role \"user\"");
-				await globalExpect(ctx.sessionPersistence.load(id)).rejects.toThrow("message must have role \"user\"");
-				const malformedLegacy = [
-					{
-						id: "invalid-old-turn-start",
-						event: {
-							type: "turn/start",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								trigger: null
-							}
-						},
-						message: "malformed pre-react-loop turn/start"
-					},
-					{
-						id: "invalid-old-steering",
-						event: {
-							type: "steering/message",
-							seq: SessionSeq(0),
-							time: 1,
-							surfaceOp: "append",
-							data: {
-								turn: 1,
-								content: [],
-								source: { kind: "user" },
-								extra: true
-							}
-						},
-						message: "malformed pre-react-loop steering/message"
-					},
-					{
-						id: "invalid-old-steering-data",
-						event: {
-							type: "steering/message",
-							seq: SessionSeq(0),
-							time: 1,
-							surfaceOp: "append",
-							data: null
-						},
-						message: "malformed pre-react-loop steering/message"
-					},
-					{
-						id: "invalid-old-turn-end",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: {
-									kind: "completed",
-									extra: true
-								}
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "invalid-old-turn-end-reason",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: null
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "unsupported-intermediate-turn-end-step",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								step: 1,
-								reason: { kind: "completed" }
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "invalid-old-turn-end-aborted",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: {
-									kind: "aborted",
-									extra: true
-								}
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "invalid-old-turn-end-disposed",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: {
-									kind: "disposed",
-									extra: true
-								}
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "invalid-old-turn-end-error-step",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: {
-									kind: "error",
-									step: -1,
-									message: "bad step"
-								}
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					},
-					{
-						id: "invalid-old-turn-end-error-code",
-						event: {
-							type: "turn/end",
-							seq: SessionSeq(0),
-							time: 1,
-							data: {
-								turn: 1,
-								reason: {
-									kind: "error",
-									step: 0,
-									message: "bad code",
-									code: 1
-								}
-							}
-						},
-						message: "malformed pre-react-loop turn/end"
-					}
-				];
-				for (const malformed of malformedLegacy) {
-					const malformedId = SessionId(malformed.id);
-					await ctx.sessionPersistence.create(meta(malformedId, WORK));
-					await ctx.sessionPersistence.append(malformedId, [malformed.event]);
-					await globalExpect(ctx.sessionPersistence.inspect(malformedId)).rejects.toThrow(malformed.message);
-					await globalExpect(ctx.sessionPersistence.readFrom(malformedId, SessionLogOffset(0))).rejects.toThrow(malformed.message);
-				}
-				for (const type of ["tool/result"]) {
-					const malformedId = SessionId(`invalid-${type}`);
-					await ctx.sessionPersistence.create(meta(malformedId, WORK));
-					await ctx.sessionPersistence.append(malformedId, [{
-						type,
-						seq: SessionSeq(0),
-						time: 1,
-						surfaceOp: "append",
-						data: { message: null }
-					}]);
-					await globalExpect(ctx.sessionPersistence.inspect(malformedId)).rejects.toThrow("lacks an identified message");
-				}
-				const pluginId = SessionId("non-object-plugin-event");
-				await ctx.sessionPersistence.create(meta(pluginId, WORK));
-				await ctx.sessionPersistence.append(pluginId, [{
-					type: "plugin/test",
-					seq: SessionSeq(0),
-					time: 1,
-					data: null,
-					ignorable: true
-				}]);
-				await globalExpect(ctx.sessionPersistence.inspect(pluginId)).rejects.toThrow(/not found/);
-				await globalExpect(ctx.sessionPersistence.readFrom(pluginId, SessionLogOffset(0))).rejects.toThrow(/not found/);
-				const requiredId = SessionId("non-object-required-plugin-event");
-				await ctx.sessionPersistence.create(meta(requiredId, WORK));
-				await ctx.sessionPersistence.append(requiredId, [{
-					type: "plugin/required",
-					seq: SessionSeq(0),
-					time: 1,
-					data: null
-				}]);
-				await globalExpect(ctx.sessionPersistence.inspect(requiredId)).rejects.toThrow(/unknown to this harness/);
-				for (const type of ["user/message", "assistant/message"]) {
-					const missingContentId = SessionId(`invalid-${type}-without-content`);
-					await ctx.sessionPersistence.create(meta(missingContentId, WORK));
-					await ctx.sessionPersistence.append(missingContentId, [{
-						type,
-						seq: SessionSeq(0),
-						time: 1,
-						surfaceOp: "append",
-						data: {}
-					}]);
-					await globalExpect(ctx.sessionPersistence.readFrom(missingContentId, SessionLogOffset(0))).rejects.toThrow("lacks an identified message");
-				}
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("append snapshots the batch: mutating the caller array/events after the call is ignored", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const m = meta("snapshot", WORK);
-				await ctx.sessionPersistence.create(m);
-				const events = structuredClone(oneTurnLog());
-				const userMsg = events[1];
-				const p = ctx.sessionPersistence.append(m.id, events);
-				events.push({
-					type: "turn/start",
-					seq: SessionSeq(6),
-					time: 99,
-					data: { turn: 2 }
-				});
-				if (userMsg?.type === "user/message") userMsg.data.content = [{
-					type: "text",
-					text: "MUTATED"
-				}];
-				await p;
-				const loaded = await ctx.sessionPersistence.load(m.id);
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3,
-					4,
-					5
-				]);
-				const persisted = JSON.stringify(loaded.events);
-				globalExpect(persisted).toContain("hi");
-				globalExpect(persisted).not.toContain("MUTATED");
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("fork: a seeded new session persists its seed once (no double-write on a no-op flush)", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const seed = oneTurnLog();
-				const forked = ctx.sessions.create(SessionId("forked"), {
-					seed,
-					meta: { cwd: WORK }
-				});
-				await ctx.sessions.flush(forked);
-				const loaded = await ctx.sessionPersistence.load(SessionId("forked"));
-				globalExpect(loaded.events.slice(0, seed.length)).toEqual(seed);
-				globalExpect(loaded.events.at(-1)).toMatchObject({
-					type: "session/end-seed",
-					seq: seed.length
-				});
-				await ctx.sessions.flush(forked);
-				const reloaded = await ctx.sessionPersistence.load(SessionId("forked"));
-				globalExpect(reloaded.events).toEqual(loaded.events);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("resume: a re-created session seeded with the loaded log does not re-append its seed and continues the seq", async () => {
-			const fix = await makeFixture();
-			const first = await freshCtx(fix);
-			try {
-				const s1 = first.ctx.sessions.create(SessionId("resumed"), { meta: { cwd: WORK } });
-				send(s1, oneTurnLog());
-				await first.ctx.sessions.flush(s1);
-			} finally {
-				await first.fiber.dispose();
-			}
-			const second = await freshCtx(fix);
-			try {
-				const loaded = await second.ctx.sessionPersistence.load(SessionId("resumed"));
-				const s2 = second.ctx.sessions.create(SessionId("resumed"), {
-					seed: loaded.events,
-					meta: { cwd: WORK }
-				});
-				await second.ctx.sessions.flush(s2);
-				s2.append("turn/start", { turn: 2 });
-				s2.append("turn/end", {
-					turn: 2,
-					reason: { kind: "completed" }
-				});
-				await second.ctx.sessions.flush(s2);
-				const reloaded = await second.ctx.sessionPersistence.load(SessionId("resumed"));
-				globalExpect(reloaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					8
-				]);
-				globalExpect(reloaded.events[6]).toMatchObject({ type: "session/end-seed" });
-			} finally {
-				await second.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("HMR: applying the plugin seeds existing live sessions", async () => {
-			const fix = await makeFixture();
-			const ctx = new Context();
-			await ctx.plugin(SessionStore);
-			const session = ctx.sessions.create(SessionId("pre-existing"), { meta: { cwd: WORK } });
-			session.append("turn/start", { turn: 1 });
-			session.append("user/message", createUserMessage({
-				content: [{
-					type: "text",
-					text: "hi"
-				}],
-				source: { kind: "user" }
-			}), { surfaceOp: "append" });
-			session.append("turn/end", {
-				turn: 1,
-				reason: { kind: "completed" }
-			});
-			const fiber = await fix.mount(ctx);
-			try {
-				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("pre-existing"));
-				globalExpect(loaded.events.length).toBeGreaterThanOrEqual(2);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("HMR: dispose drains remaining buffers", async () => {
-			const fix = await makeFixture();
-			const ctx = new Context();
-			await ctx.plugin(SessionStore);
-			const fiber = await fix.mount(ctx);
-			const session = await liveSessionInFiber(ctx, "drain", WORK);
-			session.append("turn/start", { turn: 1 });
-			session.append("user/message", createUserMessage({
-				content: [{
-					type: "text",
-					text: "buffered"
-				}],
-				source: { kind: "user" }
-			}), { surfaceOp: "append" });
-			session.append("turn/end", {
-				turn: 1,
-				reason: { kind: "completed" }
-			});
-			await fiber.dispose();
-			const second = await freshCtx(fix);
-			try {
-				const loaded = await second.ctx.sessionPersistence.load(SessionId("drain"));
-				globalExpect(loaded.events.length).toBeGreaterThanOrEqual(2);
-			} finally {
-				await second.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("HMR: reloading the backend adopts a still-live, already-materialized session", async () => {
-			const fix = await makeFixture();
-			const ctx = new Context();
-			await ctx.plugin(SessionStore);
-			const session = await liveSessionInFiber(ctx, "hmr-adopt", WORK);
-			try {
-				const backend1 = await fix.mount(ctx);
-				session.append("turn/start", { turn: 1 });
-				session.append("user/message", createUserMessage({
-					content: [{
-						type: "text",
-						text: "hi"
-					}],
-					source: { kind: "user" }
-				}), { surfaceOp: "append" });
-				session.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(session);
-				await backend1.dispose();
-				await fix.mount(ctx);
-				session.append("turn/start", { turn: 2 });
-				session.append("user/message", createUserMessage({
-					content: [{
-						type: "text",
-						text: "again"
-					}],
-					source: { kind: "user" }
-				}), { surfaceOp: "append" });
-				session.append("turn/end", {
-					turn: 2,
-					reason: { kind: "completed" }
-				});
-				await globalExpect(ctx.sessions.flush(session)).resolves.not.toThrow();
-				const loaded = await ctx.sessionPersistence.load(SessionId("hmr-adopt"));
-				globalExpect(loaded.events.filter((e) => e.type === "turn/start")).toHaveLength(2);
-			} finally {
-				await ctx.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("HMR: adoption persists the live SUFFIX that was ahead of the stored prefix", async () => {
-			const fix = await makeFixture();
-			const ctx = new Context();
-			await ctx.plugin(SessionStore);
-			const session = await liveSessionInFiber(ctx, "hmr-suffix", WORK);
-			try {
-				const backend1 = await fix.mount(ctx);
-				session.append("turn/start", { turn: 1 });
-				session.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(session);
-				await backend1.dispose();
-				session.append("turn/start", { turn: 2 });
-				session.append("turn/end", {
-					turn: 2,
-					reason: { kind: "completed" }
-				});
-				await fix.mount(ctx);
-				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("hmr-suffix"));
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3
-				]);
-				globalExpect(loaded.events.filter((e) => e.type === "turn/start")).toHaveLength(2);
-			} finally {
-				await ctx.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("HMR adoption does NOT crash-repair an active open turn as interrupted (truncate without closers)", async () => {
-			const fix = await makeFixture();
-			const ctx = new Context();
-			await ctx.plugin(SessionStore);
-			const session = await liveSessionInFiber(ctx, "hmr-open", WORK);
-			try {
-				const first = await fix.mount(ctx);
-				session.append("turn/start", { turn: 1 });
-				session.append("step/start", {
-					turn: 1,
-					step: 1
-				});
-				await ctx.sessions.flush(session);
-				await first.dispose();
-				if (fix.corruptTail) await fix.corruptTail(SessionId("hmr-open"), WORK);
-				const second = await fix.mount(ctx);
-				session.append("step/end", {
-					turn: 1,
-					step: 1
-				});
-				session.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("hmr-open"));
-				globalExpect(loaded.events.map((e) => e.type)).toEqual([
-					"turn/start",
-					"step/start",
-					"step/end",
-					"turn/end"
-				]);
-				globalExpect(loaded.events.at(-1)).toMatchObject({
-					type: "turn/end",
-					data: { reason: { kind: "completed" } }
-				});
-				await second.dispose();
-			} finally {
-				await ctx.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("a NEW live session colliding on a persisted id is rejected, not silently adopted", async () => {
-			const fix = await makeFixture();
-			const first = await freshCtx(fix);
-			try {
-				const s1 = first.ctx.sessions.create(SessionId("collide"), { meta: { cwd: WORK } });
-				send(s1, oneTurnLog());
-				await first.ctx.sessions.flush(s1);
-			} finally {
-				await first.fiber.dispose();
-			}
-			const second = await freshCtx(fix);
-			try {
-				const s2 = second.ctx.sessions.create(SessionId("collide"), { meta: { cwd: WORK } });
-				s2.append("turn/start", { turn: 1 });
-				await globalExpect(second.ctx.sessions.flush(s2)).rejects.toThrow(/already has a persisted log|id collision/);
-			} finally {
-				await second.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("an abandoned lazy session (never materialized) releases its id for reuse", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				let firstSession;
-				const firstFiber = await ctx.plugin(Object.assign((inner) => {
-					firstSession = inner.sessions.create(SessionId("abandoned"), { meta: { cwd: WORK } });
-				}, { inject: ["sessions"] }));
-				await ctx.sessions.flush(firstSession);
-				await firstFiber.dispose();
-				let reuse;
-				await ctx.plugin(Object.assign((inner) => {
-					reuse = inner.sessions.create(SessionId("abandoned"), { meta: { cwd: WORK } });
-				}, { inject: ["sessions"] }));
-				await globalExpect(ctx.sessions.flush(reuse)).resolves.toBe(true);
-				reuse.append("turn/start", { turn: 1 });
-				reuse.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await ctx.sessions.flush(reuse);
-				const loaded = await ctx.sessionPersistence.load(SessionId("abandoned"));
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([0, 1]);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("session disposal drains buffered events before retiring ownership", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				let first;
-				const firstFiber = await ctx.plugin(Object.assign((inner) => {
-					first = inner.sessions.create(SessionId("buffered"), { meta: { cwd: WORK } });
-				}, { inject: ["sessions"] }));
-				await ctx.sessions.flush(first);
-				first.append("turn/start", { turn: 1 });
-				first.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
-				});
-				await firstFiber.dispose();
-				await vi.waitFor(async () => {
-					globalExpect((await ctx.sessionPersistence.list()).map((meta) => meta.id)).toContain(SessionId("buffered"));
-				});
-				globalExpect((await ctx.sessionPersistence.load(SessionId("buffered"))).events.map((event) => event.seq)).toEqual([0, 1]);
-				let reuse;
-				await ctx.plugin(Object.assign((inner) => {
-					reuse = inner.sessions.create(SessionId("buffered"), { meta: { cwd: WORK } });
+				let session;
+				const sessionFiber = await ctx.plugin(Object.assign((inner) => {
+					session = inner.sessions.create(SessionId("delegated-child"), { meta: {
+						cwd: WORK,
+						parentSession: SessionId("root"),
+						delegationDepth: 2
+					} });
 				}, { inject: ["sessions"] }));
-				await globalExpect(ctx.sessions.flush(reuse)).rejects.toThrow(/persisted log|id collision/);
+				send(session, oneTurnLog());
+				await ctx.parallel("session/flush", session);
+				await sessionFiber.dispose();
+				const loaded = await readAll(ctx, SessionId("delegated-child"));
+				globalExpect(loaded.meta.delegationDepth).toBe(2);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("initFor is idempotent: re-emitting session/created does not re-initialize", async () => {
+		it("source-frozen events cannot be mutated after buffering and persist unchanged", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				const session = ctx.sessions.create(SessionId("idem"), { meta: { cwd: WORK } });
+				const session = ctx.sessions.create(SessionId("mutate"), { meta: { cwd: WORK } });
 				session.append("turn/start", { turn: 1 });
-				session.append("user/message", createUserMessage({
+				const ev = session.append("user/message", createUserMessage({
 					content: [{
 						type: "text",
-						text: "x"
+						text: "original"
 					}],
 					source: { kind: "user" }
 				}), { surfaceOp: "append" });
+				globalExpect(() => {
+					ev.data.content[0].text = "HACKED";
+				}).toThrow(TypeError);
 				session.append("turn/end", {
 					turn: 1,
 					reason: { kind: "completed" }
 				});
 				await ctx.sessions.flush(session);
-				ctx.emit(scopeTarget(session, void 0), "session/created", session);
-				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("idem"));
-				globalExpect(loaded.events).toHaveLength(3);
+				const message = (await readAll(ctx, SessionId("mutate"))).events.find((event) => event.type === "user/message");
+				globalExpect(message?.type === "user/message" && message.data.content[0].text).toBe("original");
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("a live session claims cursor-0 ownerless state created via the public API and persists its seed", async () => {
+		it("fork: a seeded new session persists its seed once (no double-write on a no-op flush)", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				await ctx.sessionPersistence.create(meta("lazy-claim", WORK));
-				const live = ctx.sessions.create(SessionId("lazy-claim"), {
-					seed: oneTurnLog(),
+				const seed = oneTurnLog();
+				const forked = ctx.sessions.create(SessionId("forked"), {
+					seed,
 					meta: { cwd: WORK }
 				});
-				await globalExpect(ctx.sessions.flush(live)).resolves.toBe(true);
-				const loaded = await ctx.sessionPersistence.load(SessionId("lazy-claim"));
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3,
-					4,
-					5,
-					6
-				]);
-				globalExpect(loaded.events.at(-1)).toMatchObject({ type: "session/end-seed" });
+				await ctx.sessions.flush(forked);
+				const loaded = await readAll(ctx, SessionId("forked"));
+				globalExpect(loaded.events.slice(0, seed.length)).toEqual(seed);
+				globalExpect(loaded.events.at(-1)).toMatchObject({
+					type: "session/end-seed",
+					seq: seed.length
+				});
+				await ctx.sessions.flush(forked);
+				const reloaded = await readAll(ctx, SessionId("forked"));
+				globalExpect(reloaded.events).toEqual(loaded.events);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("a fresh session reusing a previously-loaded id is rejected (ownerless guard)", async () => {
+		it("resume: a re-created session seeded with the loaded log does not re-append its seed and continues the seq", async () => {
 			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
+			const first = await freshCtx(fix);
 			try {
-				await ctx.sessionPersistence.create(meta("preview", WORK));
-				await ctx.sessionPersistence.append(SessionId("preview"), oneTurnLog());
-				await ctx.sessionPersistence.load(SessionId("preview"));
-				let fresh;
-				await ctx.plugin(Object.assign((inner) => {
-					fresh = inner.sessions.create(SessionId("preview"), { meta: { cwd: WORK } });
-				}, { inject: ["sessions"] }));
-				await globalExpect(ctx.sessions.flush(fresh)).rejects.toThrow(/do not match this live session|already has a persisted log|id collision/);
+				const s1 = first.ctx.sessions.create(SessionId("resumed"), { meta: { cwd: WORK } });
+				send(s1, oneTurnLog());
+				await first.ctx.sessions.flush(s1);
 			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
+				await first.fiber.dispose();
 			}
-		});
-		it("a live session whose complete seed matches loaded ownerless state claims it without appending", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
+			const second = await freshCtx(fix);
 			try {
-				const id = SessionId("claim-exact");
-				const completeSeed = [...oneTurnLog(), {
-					type: "session/end-seed",
-					seq: SessionSeq(6),
-					time: 7,
-					data: {}
-				}];
-				await ctx.sessionPersistence.create(meta(id, WORK));
-				await ctx.sessionPersistence.append(id, completeSeed);
-				const { events } = await ctx.sessionPersistence.load(id);
-				const live = ctx.sessions.create(id, {
-					seed: events,
+				const loaded = await readAll(second.ctx, SessionId("resumed"));
+				const s2 = second.ctx.sessions.create(SessionId("resumed"), {
+					seed: loaded.events,
 					meta: { cwd: WORK }
 				});
-				await globalExpect(ctx.sessions.flush(live)).resolves.toBe(true);
-				globalExpect((await ctx.sessionPersistence.load(id)).events).toEqual(events);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("a live session whose seed matches the loaded prefix claims ownerless state and persists the suffix", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const storedMeta = meta("claim", WORK);
-				await ctx.sessionPersistence.create(storedMeta);
-				await ctx.sessionPersistence.append(SessionId("claim"), oneTurnLog());
-				const { events, meta: durableMeta } = await ctx.sessionPersistence.load(SessionId("claim"));
-				let cont;
-				const contFiber = await ctx.plugin(Object.assign((inner) => {
-					cont = inner.sessions.create(SessionId("claim"), {
-						seed: [
-							...events,
-							{
-								type: "turn/start",
-								seq: SessionSeq(6),
-								time: 7,
-								data: { turn: 2 }
-							},
-							{
-								type: "turn/end",
-								seq: SessionSeq(7),
-								time: 8,
-								data: {
-									turn: 2,
-									reason: { kind: "completed" }
-								}
-							}
-						],
-						meta: {
-							cwd: WORK,
-							createdAt: 2e3
-						}
-					});
-				}, { inject: ["sessions"] }));
-				await ctx.sessions.flush(cont);
-				const loaded = await ctx.sessionPersistence.load(SessionId("claim"));
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
+				await second.ctx.sessions.flush(s2);
+				s2.append("turn/start", { turn: 2 });
+				s2.append("turn/end", {
+					turn: 2,
+					reason: { kind: "completed" }
+				});
+				await second.ctx.sessions.flush(s2);
+				const reloaded = await readAll(second.ctx, SessionId("resumed"));
+				globalExpect(reloaded.events.map((e) => e.seq)).toEqual([
 					0,
 					1,
 					2,
@@ -15743,60 +14503,111 @@ function runCoordinatorContract(name, makeFixture) {
 					7,
 					8
 				]);
-				globalExpect(loaded.events.at(-1)).toMatchObject({ type: "session/end-seed" });
-				globalExpect(loaded.meta).toEqual(durableMeta);
-				globalExpect(loaded.meta.createdAt).toBe(1e3);
-				await contFiber.dispose();
-				await vi.waitFor(async () => {
-					globalExpect((await ctx.sessionPersistence.load(SessionId("claim"))).meta).toEqual(durableMeta);
-				});
+				globalExpect(reloaded.events[6]).toMatchObject({ type: "session/end-seed" });
 			} finally {
-				await fiber.dispose();
+				await second.fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("a live session at a DIFFERENT cwd cannot claim cursor-0 ownerless state (cwd scope)", async () => {
+		it("HMR: applying the plugin seeds existing live sessions", async () => {
 			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
+			const ctx = new Context();
+			await ctx.plugin(SessionStore);
+			const session = ctx.sessions.create(SessionId("pre-existing"), { meta: { cwd: WORK } });
+			session.append("turn/start", { turn: 1 });
+			session.append("user/message", createUserMessage({
+				content: [{
+					type: "text",
+					text: "hi"
+				}],
+				source: { kind: "user" }
+			}), { surfaceOp: "append" });
+			session.append("turn/end", {
+				turn: 1,
+				reason: { kind: "completed" }
+			});
+			const fiber = await fix.mount(ctx);
 			try {
-				await ctx.sessionPersistence.create(meta("wrong-cwd-claim", OTHER));
-				const live = ctx.sessions.create(SessionId("wrong-cwd-claim"), {
-					seed: oneTurnLog(),
-					meta: { cwd: WORK }
-				});
-				await globalExpect(ctx.sessions.flush(live)).rejects.toThrow(/different cwd|id collision/);
+				await ctx.sessions.flush(session);
+				const loaded = await readAll(ctx, SessionId("pre-existing"));
+				globalExpect(loaded.events.length).toBeGreaterThanOrEqual(2);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("a live session at a DIFFERENT cwd cannot claim loaded-prefix ownerless state (cwd scope)", async () => {
+		it("HMR: dispose drains remaining buffers", async () => {
+			const fix = await makeFixture();
+			const ctx = new Context();
+			await ctx.plugin(SessionStore);
+			const fiber = await fix.mount(ctx);
+			const session = ctx.sessions.create(SessionId("drain"), { meta: { cwd: WORK } });
+			session.append("turn/start", { turn: 1 });
+			session.append("user/message", createUserMessage({
+				content: [{
+					type: "text",
+					text: "buffered"
+				}],
+				source: { kind: "user" }
+			}), { surfaceOp: "append" });
+			session.append("turn/end", {
+				turn: 1,
+				reason: { kind: "completed" }
+			});
+			await fiber.dispose();
+			const second = await freshCtx(fix);
+			try {
+				const loaded = await readAll(second.ctx, SessionId("drain"));
+				globalExpect(loaded.events.length).toBeGreaterThanOrEqual(2);
+			} finally {
+				await second.fiber.dispose();
+				await fix.cleanup();
+			}
+		});
+		it("a NEW live session colliding on a persisted id is rejected, not silently adopted", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				await ctx.sessionPersistence.create(meta("wrong-cwd-load", OTHER));
-				await ctx.sessionPersistence.append(SessionId("wrong-cwd-load"), oneTurnLog());
-				const { events } = await ctx.sessionPersistence.load(SessionId("wrong-cwd-load"));
-				const live = ctx.sessions.create(SessionId("wrong-cwd-load"), {
-					seed: events,
-					meta: { cwd: WORK }
-				});
-				await globalExpect(ctx.sessions.flush(live)).rejects.toThrow(/different cwd|id collision/);
+				let first;
+				const firstFiber = await ctx.plugin(Object.assign((inner) => {
+					first = inner.sessions.create(SessionId("collide"), { meta: { cwd: WORK } });
+				}, { inject: ["sessions"] }));
+				send(first, oneTurnLog());
+				await ctx.sessions.flush(first);
+				await firstFiber.dispose();
+				let second;
+				await ctx.plugin(Object.assign((inner) => {
+					second = inner.sessions.create(SessionId("collide"), { meta: { cwd: "/other" } });
+				}, { inject: ["sessions"] }));
+				await globalExpect(ctx.sessions.flush(second)).rejects.toThrow(/different cwd/);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("a no-cwd ownerless state cannot be claimed by a live session WITH a cwd (cwd scope, undefined side)", async () => {
+		it("an abandoned lazy session (never materialized) releases its id for reuse", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				await ctx.sessionPersistence.create(meta("no-cwd-state"));
-				const live = ctx.sessions.create(SessionId("no-cwd-state"), {
-					seed: oneTurnLog(),
-					meta: { cwd: WORK }
+				let firstSession;
+				const firstFiber = await ctx.plugin(Object.assign((inner) => {
+					firstSession = inner.sessions.create(SessionId("abandoned"), { meta: { cwd: WORK } });
+				}, { inject: ["sessions"] }));
+				await ctx.sessions.flush(firstSession);
+				await firstFiber.dispose();
+				let reuse;
+				await ctx.plugin(Object.assign((inner) => {
+					reuse = inner.sessions.create(SessionId("abandoned"), { meta: { cwd: WORK } });
+				}, { inject: ["sessions"] }));
+				await globalExpect(ctx.sessions.flush(reuse)).resolves.toBe(true);
+				reuse.append("turn/start", { turn: 1 });
+				reuse.append("turn/end", {
+					turn: 1,
+					reason: { kind: "completed" }
 				});
-				await globalExpect(ctx.sessions.flush(live)).rejects.toThrow(/different cwd|id collision/);
+				await ctx.sessions.flush(reuse);
+				const loaded = await readAll(ctx, SessionId("abandoned"));
+				globalExpect(loaded.events.map((e) => e.seq)).toEqual([0, 1]);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
@@ -15804,17 +14615,14 @@ function runCoordinatorContract(name, makeFixture) {
 		});
 		it("append adopts a storage-only session (fresh instance) and continues the seq", async () => {
 			const fix = await makeFixture();
-			const first = await freshCtx(fix);
-			try {
-				const m = meta("adopt-append", WORK);
-				await first.ctx.sessionPersistence.create(m);
-				await first.ctx.sessionPersistence.append(m.id, oneTurnLog());
-			} finally {
-				await first.fiber.dispose();
-			}
-			const second = await freshCtx(fix);
+			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				await second.ctx.sessionPersistence.append(SessionId("adopt-append"), [{
+				const m = meta("storage-only", WORK);
+				const handle = await ctx.sessionPersistence.create(m);
+				await handle.append(oneTurnLog());
+				await handle.close();
+				const writer = await ctx.sessionPersistence.open(SessionId("storage-only"), "write");
+				await writer.append([{
 					type: "turn/start",
 					seq: SessionSeq(6),
 					time: 7,
@@ -15828,7 +14636,8 @@ function runCoordinatorContract(name, makeFixture) {
 						reason: { kind: "completed" }
 					}
 				}]);
-				const loaded = await second.ctx.sessionPersistence.load(SessionId("adopt-append"));
+				await writer.close();
+				const loaded = await readAll(ctx, SessionId("storage-only"));
 				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
 					0,
 					1,
@@ -15839,68 +14648,21 @@ function runCoordinatorContract(name, makeFixture) {
 					6,
 					7
 				]);
-			} finally {
-				await second.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("append of an empty batch is a no-op (stays lazy)", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const m = meta("empty-batch", WORK);
-				await ctx.sessionPersistence.create(m);
-				await ctx.sessionPersistence.append(m.id, []);
-				globalExpect((await ctx.sessionPersistence.list()).map((h) => h.id)).not.toContain(m.id);
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("load and inspect reject a missing session", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				await globalExpect(ctx.sessionPersistence.load(SessionId("nope"))).rejects.toThrow(/not found/);
-				await globalExpect(ctx.sessionPersistence.inspect(SessionId("nope"))).rejects.toThrow(/not found/);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
 		it("create rejects a duplicate id (in memory and on a persisted log)", async () => {
-			const fix = await makeFixture();
-			const first = await freshCtx(fix);
-			try {
-				const m = meta("dup", WORK);
-				await first.ctx.sessionPersistence.create(m);
-				await globalExpect(first.ctx.sessionPersistence.create(m)).rejects.toThrow(/already exists in this backend/);
-				await first.ctx.sessionPersistence.append(m.id, oneTurnLog());
-			} finally {
-				await first.fiber.dispose();
-			}
-			const second = await freshCtx(fix);
-			try {
-				await globalExpect(second.ctx.sessionPersistence.create(meta("dup", WORK))).rejects.toThrow(/already has a persisted log on disk/);
-			} finally {
-				await second.fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("rejects an unknown format version on load (assertVersion)", async () => {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				const m = {
-					version: 99,
-					id: SessionId("v99"),
-					createdAt: 1,
-					cwd: WORK,
-					isSeeded: false
-				};
-				await ctx.sessionPersistence.create(m);
-				await ctx.sessionPersistence.append(m.id, oneTurnLog());
-				await globalExpect(ctx.sessionPersistence.load(m.id)).rejects.toThrow(/log format/);
+				const m = meta("dup-id", WORK);
+				const first = await ctx.sessionPersistence.create(m);
+				await globalExpect(ctx.sessionPersistence.create(m)).rejects.toThrow(/already exists/);
+				await first.append(oneTurnLog());
+				await first.close();
+				await globalExpect(ctx.sessionPersistence.create(m)).rejects.toThrow(/already exists/);
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
@@ -15910,123 +14672,49 @@ function runCoordinatorContract(name, makeFixture) {
 			const fix = await makeFixture();
 			const { ctx, fiber } = await freshCtx(fix);
 			try {
-				const m = {
-					version: SESSION_FORMAT_VERSION,
-					id: SessionId("forked-child"),
-					createdAt: 1,
-					cwd: WORK,
-					parentSession: SessionId("the-parent"),
-					isSeeded: false
-				};
-				await ctx.sessionPersistence.create(m);
-				await ctx.sessionPersistence.append(m.id, oneTurnLog());
-				const loaded = await ctx.sessionPersistence.load(m.id);
-				globalExpect(loaded.meta.parentSession).toBe("the-parent");
-			} finally {
-				await fiber.dispose();
-				await fix.cleanup();
-			}
-		});
-		it("flush before init resolves uses cursor 0", async () => {
-			const fix = await makeFixture();
-			const { ctx, fiber } = await freshCtx(fix);
-			try {
-				const session = ctx.sessions.create(SessionId("flush-nostate"), { meta: { cwd: WORK } });
-				session.append("turn/start", { turn: 1 });
-				session.append("user/message", createUserMessage({
-					content: [{
-						type: "text",
-						text: "q"
-					}],
-					source: { kind: "user" }
-				}), { surfaceOp: "append" });
-				session.append("turn/end", {
-					turn: 1,
-					reason: { kind: "completed" }
+				const m = meta("lineage", WORK);
+				const handle = await ctx.sessionPersistence.create({
+					...m,
+					parentSession: SessionId("parent")
 				});
-				await ctx.sessions.flush(session);
-				const loaded = await ctx.sessionPersistence.load(SessionId("flush-nostate"));
-				globalExpect(loaded.events).toHaveLength(3);
+				await handle.append(oneTurnLog());
+				await handle.close();
+				const loaded = await readAll(ctx, SessionId("lineage"));
+				globalExpect(loaded.meta.parentSession).toBe(SessionId("parent"));
 			} finally {
 				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});
-		it("torn-tail load: a never-committed tail is truncated and the open turn closed during load (commitRepair w/ tornMarker)", async () => {
+		it("torn-tail: a never-committed tail is truncated by the write path", async () => {
 			const fix = await makeFixture();
-			if (!fix.corruptTail) {
-				globalExpect(fix.corruptTail).toBeUndefined();
-				await fix.cleanup();
-				return;
-			}
-			const first = await freshCtx(fix);
+			if (fix.corruptTail === void 0) return;
+			const { ctx, fiber } = await freshCtx(fix);
 			try {
 				const m = meta("torn", WORK);
-				await first.ctx.sessionPersistence.create(m);
-				await first.ctx.sessionPersistence.append(m.id, oneTurnLog());
-				await first.ctx.sessionPersistence.append(m.id, [{
+				const creator = await ctx.sessionPersistence.create(m);
+				await creator.append(oneTurnLog());
+				await creator.close();
+				await fix.corruptTail(SessionId("torn"), WORK);
+				const reader = await ctx.sessionPersistence.open(SessionId("torn"), "read");
+				globalExpect((await reader.read()).events).toEqual(oneTurnLog());
+				await reader.close();
+				const writer = await ctx.sessionPersistence.open(SessionId("torn"), "write");
+				await writer.append([{
 					type: "turn/start",
 					seq: SessionSeq(6),
 					time: 7,
 					data: { turn: 2 }
 				}, {
-					type: "step/start",
+					type: "turn/end",
 					seq: SessionSeq(7),
 					time: 8,
 					data: {
 						turn: 2,
-						step: 1
-					}
-				}]);
-			} finally {
-				await first.fiber.dispose();
-			}
-			await fix.corruptTail(SessionId("torn"), WORK);
-			const second = await freshCtx(fix);
-			try {
-				const loaded = await second.ctx.sessionPersistence.load(SessionId("torn"));
-				globalExpect(loaded.events.map((e) => e.seq)).toEqual([
-					0,
-					1,
-					2,
-					3,
-					4,
-					5,
-					6,
-					7,
-					8,
-					9
-				]);
-				globalExpect(loaded.events.map((e) => e.type)).toEqual([
-					"turn/start",
-					"user/message",
-					"step/start",
-					"assistant/message",
-					"step/end",
-					"turn/end",
-					"turn/start",
-					"step/start",
-					"step/end",
-					"turn/end"
-				]);
-				const last = loaded.events.at(-1);
-				globalExpect(last.type === "turn/end" && last.data.reason).toEqual({ kind: "interrupted" });
-				await second.ctx.sessionPersistence.append(SessionId("torn"), [{
-					type: "turn/start",
-					seq: SessionSeq(10),
-					time: 9,
-					data: { turn: 3 }
-				}, {
-					type: "turn/end",
-					seq: SessionSeq(11),
-					time: 10,
-					data: {
-						turn: 3,
 						reason: { kind: "completed" }
 					}
 				}]);
-				const reloaded = await second.ctx.sessionPersistence.load(SessionId("torn"));
-				globalExpect(reloaded.events.map((e) => e.seq)).toEqual([
+				globalExpect((await writer.read()).events.map((e) => e.seq)).toEqual([
 					0,
 					1,
 					2,
@@ -16034,14 +14722,11 @@ function runCoordinatorContract(name, makeFixture) {
 					4,
 					5,
 					6,
-					7,
-					8,
-					9,
-					10,
-					11
+					7
 				]);
+				await writer.close();
 			} finally {
-				await second.fiber.dispose();
+				await fiber.dispose();
 				await fix.cleanup();
 			}
 		});