@yielded/agent-storage-memory 0.1.0-beta.167 → 0.1.0-beta.168

package/dist/MemoryThreadStore.mjs

@@ -1,20 +1,325 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Context, Crypto, Effect, Layer, Option, PubSub, Ref, Schema, Stream } from "effect";
-import { ThreadId } from "@yielded/agent/identifiers";
+import { n as MemoryThreadStoreKernel, t as boundedWorkSelection } from "./WorkSelection-CmqTuws3.mjs";
+import { Context, Crypto, Effect, Layer, MutableRef, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect";
+import { RunId, SubmissionId, ThreadId } from "@yielded/agent/identifiers";
+import { submissionAbortRecordId, submissionInputRecordId, submissionSettlementRecordId } from "@yielded/agent/submission-ledger";
+import { ThreadDeliveryImportReader, ThreadImport, ThreadImportReader, ThreadImportRejected, captureImportSource, finishThreadImport, invalidThreadArchive, makeThreadImportProgress, prepareImportPage, rebuildClosedSubmission, validateClosedRun, verifyImportedReferences } from "@yielded/agent/thread-import";
+import { AppendConflict, AppendResult, CheckpointRejected, LoadCheckpointRequest, PROMPT_EVIDENCE_TAGS, PreparedAppend, SaveCheckpointRequest, ThreadExportRecord, ThreadExportRejected, ThreadExportSource, ThreadIdentity, ThreadIdentityRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadPeerCountRequest, ThreadPromptRead, ThreadReadRequest, ThreadReader, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, ThreadVerificationRequest, ThreadWorkerCapacity, ThreadWorkerCapacityRequest, canonicalBatchFitsTransfer, streamExport, transferPageFits } from "@yielded/agent/thread-store";
+import { MAX_WORK_REBUILD_BYTES, MAX_WORK_REBUILD_RECORDS, ThreadWorkRequest, WORK_INDEX_VERSION, WorkDiscoveryUnavailable, WorkIndexRebuildRequest, WorkThreadsRequest, advanceWorkEntry, decodeWorkCursor, encodeWorkCursor, validateWorkPage, workIndexChanges } from "@yielded/agent/thread-work";
 import { Base64 } from "effect/encoding";
-import { CanonicalRecordEnvelope, CanonicalSequence, ObservationOffset } from "@yielded/agent/records";
-import { EMPTY_TAIL_DIGEST, digestCanonicalBatch } from "@yielded/agent/digest";
-import { runIdForSubmission, subagentLineageRecordId, workerOriginRecordId } from "@yielded/agent/run-journal";
-import { AppendConflict, AppendResult, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, MAX_THREAD_EXPORT_RECORDS, SaveCheckpointRequest, SaveRecoveryCheckpointRequest, ThreadExport, ThreadExportRequest, ThreadIdentity, ThreadIdentityRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadPeerCountRequest, ThreadReadRequest, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest } from "@yielded/agent/thread-store";
+import { canonicalJson, utf8ByteLength } from "@yielded/agent/digest";
+import { CURRENT_RECORD_FORMAT, CanonicalRecordEnvelope, CanonicalSequence, MAX_RUN_EVIDENCE_BYTES, MAX_RUN_EVIDENCE_RECORDS, MAX_RUN_RECOVERY_SUFFIX_BYTES, MAX_RUN_RECOVERY_SUFFIX_RECORDS, MAX_RUN_TERMINAL_BYTES, ObservationOffset, PromptRecord, RUN_TERMINAL_RESERVE_RECORDS, RecordEnvelope } from "@yielded/agent/records";
+import { runIdForSubmission, subagentLineageRecordId, toolCallSettledRecordId, workerInputRecordId, workerOriginRecordId } from "@yielded/agent/run-journal";
+import { ExportBatch, ExportRecord, ExportedRecord, ReadRecord } from "@yielded/agent/record-format";
+import { ProgressAppendReader, canonicalRecordBytes, canonicalRunIds, isWorkHandoff, prepareProgressAppend, validateProgressAppend, verifyRunContinuations } from "@yielded/agent/run-continuation";
+import { StorageOwner, makeStorageOwner } from "@yielded/agent/run-storage";
+import { MAX_ARCHIVE_RANGE_BYTES, MAX_ARCHIVE_RANGE_RECORDS, ThreadArchiveRange, ThreadArchiveRangePublish, ThreadArchiveRangeRead, ThreadArchiveRangeRequest, ThreadArchiveRangeSeal } from "@yielded/agent/thread-archive-range";
+import { verifyThreadInvariants } from "@yielded/agent/thread-invariants";
+import { ThreadExporterReader, checkExportSource, exportThreadPage } from "@yielded/agent/thread-transfer";
 //#region src/MemoryThreadStore.ts
 var MemoryThreadStore_exports = /* @__PURE__ */ __exportAll({
 	MemoryThreadStoreLive: () => MemoryThreadStoreLive,
 	memoryThreadStoreLayer: () => memoryThreadStoreLayer
 });
 const MAX_THREADS = 256;
-const MAX_RECORDS_PER_THREAD = MAX_THREAD_EXPORT_RECORDS;
+const RECORD_CHUNK_SIZE = 1024;
+const READ_PAGE_SIZE = 8;
 const MAX_CHECKPOINTS_PER_THREAD = 1024;
 const ThreadCapacity = Context.Reference("@effect-agent/storage-memory/MemoryThreadStore/ThreadCapacity", { defaultValue: () => MAX_THREADS });
+const storedRecord = (thread, sequence) => thread.chunks.get(Math.floor((sequence - 1) / RECORD_CHUNK_SIZE))?.records[(sequence - 1) % RECORD_CHUNK_SIZE];
+const isBatchBoundary = (thread, sequence) => {
+	if (sequence === 0) return true;
+	const record = storedRecord(thread, sequence);
+	return record !== void 0 && thread.batches.get(record.batchId)?.result.lastSequence === sequence;
+};
+const storedBytes = (thread, sequence) => thread.chunks.get(Math.floor((sequence - 1) / RECORD_CHUNK_SIZE))?.bytes[(sequence - 1) % RECORD_CHUNK_SIZE];
+const storedPage = (thread, after, limit) => {
+	const page = [];
+	let bytes = 0;
+	for (let sequence = after + 1; sequence <= Math.min(thread.tailSequence, after + limit); sequence++) {
+		const record = storedRecord(thread, sequence);
+		if (record === void 0) throw new Error("Incomplete canonical chunk table");
+		const size = storedBytes(thread, sequence) ?? 0;
+		if (bytes + size > 33554432) break;
+		bytes += size;
+		page.push(record);
+	}
+	return page;
+};
+const retainRecords = (thread, records) => {
+	for (const entry of records) {
+		const chunkId = Math.floor((entry.sequence - 1) / RECORD_CHUNK_SIZE);
+		let chunk = thread.chunks.get(chunkId);
+		if (chunk === void 0) {
+			chunk = {
+				records: [],
+				bytes: []
+			};
+			thread.chunks.set(chunkId, chunk);
+		}
+		chunk.records.push(entry);
+		chunk.bytes.push(canonicalRecordBytes(entry.record));
+	}
+};
+const emptyIndexes = () => ({
+	toolDeclarations: /* @__PURE__ */ new Map(),
+	promptEvidence: [],
+	modelCompletions: [],
+	applicationInputs: [],
+	durableOwners: [],
+	windowBoundaries: /* @__PURE__ */ new Map(),
+	peerCount: 0,
+	workerRecords: /* @__PURE__ */ new Map(),
+	byId: /* @__PURE__ */ new Map(),
+	runInputs: /* @__PURE__ */ new Map(),
+	runRecords: /* @__PURE__ */ new Map(),
+	handoffs: [],
+	agentUpdates: [],
+	deliveryPredecessors: [],
+	operationRecords: /* @__PURE__ */ new Map()
+});
+const liveInputPosition = (entries, sequence) => {
+	let low = 0;
+	let high = entries.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		if (entries[middle].sequence < sequence) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+const changeLiveInput = (entries, entry, change) => {
+	const at = liveInputPosition(entries, entry.createdSequence);
+	if (change === 1) entries.splice(at, 0, {
+		sequence: entry.createdSequence,
+		id: entry.id
+	});
+	else if (entries[at]?.id === entry.id) entries.splice(at, 1);
+};
+const emptyWorkIndex = () => ({
+	version: WORK_INDEX_VERSION,
+	state: "ready",
+	through: ZERO_CANONICAL_SEQUENCE,
+	reporting: "none",
+	entryCount: 0,
+	entries: /* @__PURE__ */ new Map(),
+	messages: /* @__PURE__ */ new Map(),
+	foreign: {
+		child: 0,
+		worker: 0,
+		delivery: 0,
+		peer: 0
+	},
+	workers: /* @__PURE__ */ new Map(),
+	liveInputs: [],
+	inputsByWorker: /* @__PURE__ */ new Map()
+});
+const changeWorkCounts = (index, entry, change) => {
+	const owner = entry.owner;
+	if (owner._tag === "Child" || owner._tag === "Handoff" && (owner.kind === "reservation" || owner.kind === "child-accounting")) index.foreign.child += change;
+	if ([
+		"WorkerInput",
+		"WorkerEffects",
+		"Report"
+	].includes(owner._tag) || owner._tag === "Handoff" && owner.kind === "worker-stop") index.foreign.worker += change;
+	if (owner._tag === "Handoff" && [
+		"peer",
+		"update",
+		"report"
+	].includes(owner.kind)) index.foreign.delivery += change;
+	if (owner._tag === "Handoff" && owner.kind === "peer") index.foreign.peer += change;
+	if (owner._tag === "WorkerInput") {
+		changeLiveInput(index.liveInputs, entry, change);
+		let inputs = index.inputsByWorker.get(owner.workerThreadId);
+		if (inputs === void 0) index.inputsByWorker.set(owner.workerThreadId, inputs = []);
+		changeLiveInput(inputs, entry, change);
+		if (inputs.length === 0) index.inputsByWorker.delete(owner.workerThreadId);
+		let worker = index.workers.get(owner.workerThreadId);
+		if (worker === void 0) index.workers.set(owner.workerThreadId, worker = {
+			ordinary: 0,
+			update: 0,
+			effects: 0
+		});
+		if (owner.update) worker.update += change;
+		else worker.ordinary += change;
+		if (worker.ordinary + worker.update + worker.effects === 0) index.workers.delete(owner.workerThreadId);
+	}
+};
+/** Prepare only this batch's changes; commit under the writer gate with canonical publication. */
+const prepareWork = Effect.fnUntraced(function* (previous, records, retained) {
+	const changes = /* @__PURE__ */ new Map();
+	let reporting = previous.reporting;
+	let through = previous.through;
+	for (const record of records) {
+		for (const change of yield* workIndexChanges(record, reporting)) if (change._tag === "WorkerMode") reporting = change.mode;
+		else if (change._tag === "Remove") {
+			const entry = changes.has(change.id) ? changes.get(change.id) : previous.entries.get(change.id);
+			if (change.stateRecordId === void 0 || entry?.stateReference._tag === "Canonical" && entry.stateReference.recordId === change.stateRecordId) changes.set(change.id, void 0);
+		} else {
+			const entry = advanceWorkEntry(changes.has(change.entry.id) ? changes.get(change.entry.id) : previous.entries.get(change.entry.id), change.entry);
+			changes.set(entry.id, entry.owner._tag === "Handoff" && entry.owner.messageId !== void 0 && retained(record.threadId, entry.owner.messageId) ? void 0 : entry);
+		}
+		through = record.sequence;
+	}
+	return () => {
+		const { entries, messages } = previous;
+		for (const [id, entry] of changes) {
+			const old = entries.get(id);
+			if (old !== void 0) changeWorkCounts(previous, old, -1);
+			if (old?.owner._tag === "Handoff" && old.owner.messageId !== void 0) {
+				const ids = messages.get(old.owner.messageId);
+				ids?.delete(id);
+				if (ids?.size === 0) messages.delete(old.owner.messageId);
+			}
+			if (entry === void 0) entries.delete(id);
+			else {
+				entries.set(id, entry);
+				changeWorkCounts(previous, entry, 1);
+				if (entry.owner._tag === "Handoff" && entry.owner.messageId !== void 0) {
+					const ids = messages.get(entry.owner.messageId);
+					if (ids === void 0) messages.set(entry.owner.messageId, /* @__PURE__ */ new Set([id]));
+					else ids.add(id);
+				}
+			}
+		}
+		return {
+			...previous,
+			through,
+			reporting,
+			entryCount: entries.size
+		};
+	};
+});
+/** First sequence strictly after the cursor, without traversing a Run's earlier facts. */
+const upperSequence = (records, sequence) => {
+	let low = 0;
+	let high = records.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		if (records[mid].sequence <= sequence) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+};
+const appendToIndex = (index, key, entry) => {
+	const records = index.get(key);
+	if (records === void 0) index.set(key, [entry]);
+	else records.push(entry);
+};
+/** Only call at successful synchronous publication, or on indexes not yet reachable by readers. */
+const commitIndex = (index, additions) => {
+	for (const [key, entries] of additions) {
+		const records = index.get(key);
+		if (records === void 0) index.set(key, entries);
+		else for (const entry of entries) records.push(entry);
+	}
+};
+const prepareIndexes = (previous, records) => {
+	let peerCount = previous.peerCount;
+	const workerRecords = /* @__PURE__ */ new Map();
+	const wasWorker = (previous.workerRecords.get("worker") ?? []).some(({ record }) => record.payload._tag === "WorkerOriginRecorded");
+	const isWorker = wasWorker || records.some(({ record }) => record.payload._tag === "WorkerOriginRecorded");
+	if (isWorker && !wasWorker) for (const entry of previous.byId.values()) {
+		const payload = entry.record.payload;
+		if ((payload._tag === "UserInputRecorded" || payload._tag === "SubmissionSettled") && payload.runId !== void 0) {
+			const key = `execution:${payload._tag}`;
+			if ((workerRecords.get(key)?.[0]?.sequence ?? 0) < entry.sequence) workerRecords.set(key, [entry]);
+		}
+	}
+	const workerAppends = /* @__PURE__ */ new Map();
+	const byId = /* @__PURE__ */ new Map();
+	const runInputs = /* @__PURE__ */ new Map();
+	const runRecords = /* @__PURE__ */ new Map();
+	const handoffs = [];
+	const agentUpdates = [];
+	const deliveryPredecessors = [];
+	const nativeAdds = emptyIndexes();
+	const operationAppends = /* @__PURE__ */ new Map();
+	for (const entry of records) {
+		byId.set(entry.record.recordId, entry);
+		const payload = entry.record.payload;
+		if (payload._tag === "ModelResponseRecorded") for (const operation of payload.toolOperations) {
+			const id = toolCallSettledRecordId(payload.runId, payload.turn, operation.toolCallId);
+			nativeAdds.toolDeclarations.set(id, previous.toolDeclarations.has(id) || nativeAdds.toolDeclarations.has(id) ? null : entry);
+		}
+		if (PROMPT_EVIDENCE_TAGS.some((tag) => tag === payload._tag)) nativeAdds.promptEvidence.push(entry);
+		if (payload._tag === "ModelCompleted") nativeAdds.modelCompletions.push(entry);
+		if (payload._tag === "UserInputRecorded") {
+			const message = payload.messageAdmission;
+			if (message === void 0 || !("_tag" in message) || message._tag !== "WorkerCompletion" && message._tag !== "WorkerUpdate") nativeAdds.applicationInputs.push(entry);
+		}
+		if (payload._tag === "UserInputRecorded" && payload.submissionId !== void 0 || [
+			"RunStarted",
+			"SubmissionSettled",
+			"AbortRequested",
+			"WorkerOriginRecorded",
+			"SubagentLineageRecorded"
+		].includes(payload._tag)) nativeAdds.durableOwners.push(entry);
+		if (payload._tag === "CompactionCreated" && payload.kind === "rollover") for (let height = 0; height < 53; height++) appendToIndex(nativeAdds.windowBoundaries, `${height}:${Math.floor(payload.coversThrough / 2 ** height)}`, entry);
+		for (const runId of canonicalRunIds(entry.record)) appendToIndex(runRecords, runId, entry);
+		if (isWorkHandoff(entry.record)) handoffs.push(entry);
+		if (payload._tag === "AgentUpdateEmitted") agentUpdates.push(entry);
+		if (payload._tag === "WorkerReportPrepared" || payload._tag === "AgentUpdateEmitted" && payload.delivery !== void 0) deliveryPredecessors.push(entry);
+		if ("runId" in payload && payload.runId !== void 0 && "toolCallId" in payload) {
+			appendToIndex(operationAppends, JSON.stringify([payload.runId, payload.toolCallId]), entry);
+			if (payload._tag === "ToolApprovalRequested" || payload._tag === "ToolApprovalDecided") appendToIndex(operationAppends, JSON.stringify([
+				payload.runId,
+				payload.toolCallId,
+				"approval"
+			]), entry);
+			if (payload._tag === "ToolCallSettled") appendToIndex(operationAppends, JSON.stringify([
+				payload.runId,
+				payload.toolCallId,
+				"settled"
+			]), entry);
+		}
+		if (payload._tag === "PeerMessagePrepared") peerCount++;
+		if (isWorker && (payload._tag === "UserInputRecorded" || payload._tag === "SubmissionSettled") && payload.runId !== void 0) workerRecords.set(`execution:${payload._tag}`, [entry]);
+		const workerKey = payload._tag === "SubtreeBudgetReserved" ? `subtree:${payload.sourceSubmissionId ?? ""}` : payload._tag === "SubagentJoined" ? `joined:${payload.runId}` : [
+			"ThreadCreated",
+			"WorkerOriginRecorded",
+			"SubagentLineageRecorded"
+		].includes(payload._tag) ? "worker" : void 0;
+		if (workerKey !== void 0) appendToIndex(workerAppends, workerKey, entry);
+		if (payload._tag === "WorkerStopRequested") appendToIndex(workerAppends, `stop:${payload.command.worker.threadId}`, entry);
+		if (payload._tag === "WorkerInputRequested" && payload.admission.sourceSubmissionId !== void 0) appendToIndex(workerAppends, `funding:${payload.admission.sourceSubmissionId}`, entry);
+		if (payload._tag === "WorkerInputCompleted") {
+			const admission = (previous.byId.get(workerInputRecordId(payload.messageId)) ?? byId.get(workerInputRecordId(payload.messageId)))?.record.payload;
+			if (admission?._tag === "WorkerInputRequested" && admission.admission.sourceSubmissionId !== void 0) appendToIndex(workerAppends, `funding:${admission.admission.sourceSubmissionId}`, entry);
+		}
+		if (payload._tag === "WorkerInputRefused") {
+			const reserved = (previous.byId.get(payload.reservation.recordId) ?? byId.get(payload.reservation.recordId))?.record.payload;
+			const sourceSubmissionId = reserved?._tag === "WorkerInputRequested" ? reserved.admission.sourceSubmissionId : reserved?._tag === "SubtreeBudgetReserved" ? reserved.sourceSubmissionId : void 0;
+			if (sourceSubmissionId !== void 0) appendToIndex(workerAppends, `funding:${sourceSubmissionId}`, entry);
+		}
+		if (payload._tag === "UserInputRecorded" && payload.kind === "user" && payload.runId !== void 0) runInputs.set(payload.runId, runInputs.has(payload.runId) || previous.runInputs.has(payload.runId) ? null : entry);
+	}
+	return {
+		indexes: {
+			...previous,
+			peerCount
+		},
+		commit: () => {
+			commitIndex(previous.runRecords, runRecords);
+			commitIndex(previous.operationRecords, operationAppends);
+			for (const [id, entry] of nativeAdds.toolDeclarations) previous.toolDeclarations.set(id, entry);
+			for (const key of [
+				"promptEvidence",
+				"modelCompletions",
+				"applicationInputs"
+			]) for (const entry of nativeAdds[key]) previous[key].push(entry);
+			commitIndex(previous.windowBoundaries, nativeAdds.windowBoundaries);
+			if (previous.durableOwners.length === 0 && nativeAdds.durableOwners[0] !== void 0) previous.durableOwners.push(nativeAdds.durableOwners[0]);
+			for (const [id, entry] of byId) previous.byId.set(id, entry);
+			for (const [id, entry] of runInputs) previous.runInputs.set(id, entry);
+			for (const [key, entries] of workerRecords) previous.workerRecords.set(key, entries);
+			commitIndex(previous.workerRecords, workerAppends);
+			for (const entry of handoffs) previous.handoffs.push(entry);
+			for (const entry of agentUpdates) previous.agentUpdates.push(entry);
+			for (const entry of deliveryPredecessors) previous.deliveryPredecessors.push(entry);
+		}
+	};
+};
 const storeError = (operation, message, cause) => cause === void 0 ? ThreadStoreError.make({
 	operation,
 	message
@@ -23,27 +328,38 @@ const storeError = (operation, message, cause) => cause === void 0 ? ThreadStore
 	message,
 	cause
 });
-const validate = Effect.fn("MemoryThreadStore.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error))));
+const validate = (schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error)));
 const decodeCanonicalSequence = Schema.decodeSync(CanonicalSequence);
 const ZERO_CANONICAL_SEQUENCE = decodeCanonicalSequence(0);
-const offsetSequence = Effect.fn("MemoryThreadStore.offsetSequence")((threadId, offset) => {
-	if (offset === void 0) return Effect.succeed(ZERO_CANONICAL_SEQUENCE);
+const offsetSequence = Effect.fnUntraced(function* (threadId, offset) {
+	if (offset === void 0) return yield* Effect.succeed(ZERO_CANONICAL_SEQUENCE);
 	const prefix = `memory:v1:${Base64.encode(threadId)}:`;
 	const encodedSequence = offset.startsWith(prefix) ? offset.slice(prefix.length) : "";
-	if (!/^\d+$/.test(encodedSequence)) return Effect.fail(storeError("observe", "Malformed observation offset"));
+	if (!/^\d+$/.test(encodedSequence)) return yield* Effect.fail(storeError("observe", "Malformed observation offset"));
 	const sequence = Number(encodedSequence);
-	return Number.isSafeInteger(sequence) ? Schema.decodeEffect(CanonicalSequence)(sequence).pipe(Effect.mapError(() => storeError("observe", "Malformed observation offset"))) : Effect.fail(storeError("observe", "Malformed observation offset"));
+	return yield* Number.isSafeInteger(sequence) ? Schema.decodeEffect(CanonicalSequence)(sequence).pipe(Effect.mapError(() => storeError("observe", "Malformed observation offset"))) : Effect.fail(storeError("observe", "Malformed observation offset"));
 });
 const observationOffset = (threadId, sequence) => Schema.decodeSync(ObservationOffset)(`memory:v1:${Base64.encode(threadId)}:${sequence}`);
-const findThread = Effect.fn("MemoryThreadStore.findThread")((state, threadId) => {
+const batchEnvelopes = (threadId, batch, firstSequence) => batch.records.map((record, index) => {
+	const sequence = decodeCanonicalSequence(firstSequence + index);
+	return CanonicalRecordEnvelope.make({
+		threadId,
+		batchId: batch.batchId,
+		sequence,
+		offset: observationOffset(threadId, sequence),
+		record
+	});
+});
+const decodeStoredBatch = (batchJson, operation) => Schema.decodeEffect(Schema.fromJsonString(ExportBatch))(batchJson).pipe(Effect.mapError((cause) => storeError(operation, "Invalid canonical batch JSON", cause)));
+const findThread = Effect.fnUntraced(function* (state, threadId) {
 	const thread = state.threads.get(threadId);
-	return thread === void 0 ? Effect.fail(ThreadNotMaterialized.make({ threadId })) : Effect.succeed(thread);
+	return yield* thread === void 0 ? Effect.fail(ThreadNotMaterialized.make({ threadId })) : Effect.succeed(thread);
 });
 const CheckpointVersionEnvelope = Schema.Struct({ checkpoint: Schema.Struct({
 	threadId: ThreadId,
 	schemaVersion: Schema.Natural
 }) });
-const validateCheckpointVersion = Effect.fn("MemoryThreadStore.validateCheckpointVersion")(function* (value) {
+const validateCheckpointVersion = Effect.fnUntraced(function* (value) {
 	const envelope = yield* Schema.decodeUnknownEffect(CheckpointVersionEnvelope)(value).pipe(Effect.mapError(() => storeError("saveCheckpoint", "Invalid saveCheckpoint request")));
 	if (envelope.checkpoint.schemaVersion !== 1) return yield* CheckpointRejected.make({
 		threadId: envelope.checkpoint.threadId,
@@ -54,79 +370,303 @@ const makeThreadStore = Effect.gen(function* () {
 	const maxThreads = yield* ThreadCapacity;
 	const crypto = yield* Crypto.Crypto;
 	const state = yield* Ref.make({ threads: /* @__PURE__ */ new Map() });
+	const gate = yield* Semaphore.make(1);
+	const owner = yield* makeStorageOwner(gate.withPermits(1));
+	const withMutation = owner.withMutation;
 	const updates = yield* PubSub.sliding(1);
+	let ledgerTransfer;
+	let deliveryTransfer;
+	const workState = yield* Ref.make(/* @__PURE__ */ new Map());
+	const workOwners = /* @__PURE__ */ new Map();
+	let deliveryLookup;
+	const retainedDelivery = (threadId, messageId) => deliveryLookup?.(threadId, messageId) ?? false;
+	const publishWork = (threadId, index) => MutableRef.get(workState.ref).set(threadId, index);
+	const retainDelivery = (threadId, messageId) => {
+		const index = MutableRef.get(workState.ref).get(threadId);
+		const ids = index?.messages.get(messageId);
+		if (index === void 0 || index.version !== WORK_INDEX_VERSION || index.entryCount !== index.entries.size || ids === void 0) return;
+		const { entries, messages } = index;
+		for (const id of ids) {
+			const entry = entries.get(id);
+			if (entry !== void 0) changeWorkCounts(index, entry, -1);
+			entries.delete(id);
+		}
+		messages.delete(messageId);
+		publishWork(threadId, {
+			...index,
+			entryCount: entries.size
+		});
+	};
+	const readyIndex = (threadId, tail) => {
+		const index = MutableRef.get(workState.ref).get(threadId);
+		if (index === void 0 || index.version !== WORK_INDEX_VERSION || index.entries.size !== index.entryCount) return Effect.fail(WorkDiscoveryUnavailable.make({
+			threadId,
+			reason: "missing-index"
+		}));
+		if (index.state !== "ready" || index.through !== tail) return Effect.fail(WorkDiscoveryUnavailable.make({
+			threadId,
+			reason: "incomplete-rebuild"
+		}));
+		return Effect.succeed(index);
+	};
+	const work = {
+		threads: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(WorkThreadsRequest, "work threads", unvalidated);
+			const current = yield* Ref.get(state);
+			const catalogue = yield* Ref.get(workState);
+			const candidates = boundedWorkSelection(request.limit, (id) => id, request.afterThreadId);
+			for (const [threadId, thread] of current.threads) {
+				const index = catalogue.get(threadId);
+				if (index === void 0 || index.version !== WORK_INDEX_VERSION || index.state !== "ready" || index.through !== thread.tailSequence || index.entryCount !== index.entries.size || index.entryCount > 0) candidates.add(threadId);
+			}
+			for (const owner of workOwners.values()) {
+				const page = yield* owner.threads(request);
+				for (const threadId of page.threadIds) candidates.add(threadId);
+			}
+			const threadIds = candidates.values;
+			const afterThreadId = threadIds.length === request.limit ? threadIds.at(-1) : void 0;
+			return {
+				threadIds,
+				...afterThreadId === void 0 ? {} : { afterThreadId }
+			};
+		})),
+		page: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(ThreadWorkRequest, "work page", unvalidated);
+			const cursor = yield* decodeWorkCursor(request).pipe(Effect.provideService(Crypto.Crypto, crypto));
+			const thread = (yield* Ref.get(state)).threads.get(request.threadId);
+			const index = yield* readyIndex(request.threadId, thread?.tailSequence ?? 0);
+			if (cursor.source === "canonical") {
+				const candidates = boundedWorkSelection(request.limit + 1, (entry) => entry.id, cursor.after);
+				for (const entry of index.entries.values()) candidates.add(entry);
+				const selected = candidates.values;
+				const entries = selected.slice(0, request.limit);
+				const after = selected.length > request.limit ? entries.at(-1)?.id : void 0;
+				return yield* validateWorkPage({
+					entries,
+					cursor: encodeWorkCursor({
+						version: WORK_INDEX_VERSION,
+						threadDigest: cursor.threadDigest,
+						source: after === void 0 ? "deliveries" : "canonical",
+						...after === void 0 ? {} : { after }
+					})
+				}, request.limit);
+			}
+			const page = yield* workOwners.get(cursor.source)?.page(request.threadId, cursor.after, request.limit) ?? Effect.succeed({ entries: [] });
+			const next = page.after === void 0 ? cursor.source === "admissions" ? "canonical" : void 0 : cursor.source;
+			return yield* validateWorkPage({
+				entries: [...page.entries],
+				...next === void 0 ? {} : { cursor: encodeWorkCursor({
+					version: WORK_INDEX_VERSION,
+					threadDigest: cursor.threadDigest,
+					source: next,
+					...page.after === void 0 ? {} : { after: page.after }
+				}) }
+			}, request.limit);
+		})),
+		rebuild: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(WorkIndexRebuildRequest, "rebuild work", unvalidated);
+			const current = yield* Ref.get(state);
+			const thread = current.threads.get(request.threadId);
+			const tail = thread?.tailSequence ?? ZERO_CANONICAL_SEQUENCE;
+			const prior = (yield* Ref.get(workState)).get(request.threadId);
+			const index = request.restart || prior === void 0 || prior.version !== WORK_INDEX_VERSION || prior.entries.size !== prior.entryCount || prior.state === "ready" && prior.through !== tail ? {
+				...emptyWorkIndex(),
+				state: "rebuilding",
+				rebuildingIndexes: emptyIndexes()
+			} : prior;
+			if (index.state === "ready") return {
+				version: WORK_INDEX_VERSION,
+				threadId: request.threadId,
+				state: "ready",
+				throughSequence: index.through,
+				tailSequence: tail,
+				processedRecords: 0,
+				processedBytes: 0
+			};
+			if (index.rebuildingIndexes === void 0) return yield* WorkDiscoveryUnavailable.make({
+				threadId: request.threadId,
+				reason: "incomplete-rebuild"
+			});
+			const rebuildingIndexes = index.rebuildingIndexes;
+			const records = [];
+			let bytes = 0;
+			const end = Math.min(tail, index.through + (request.limit ?? MAX_WORK_REBUILD_RECORDS));
+			for (let position = index.through; position < end; position++) {
+				const size = thread === void 0 ? void 0 : storedBytes(thread, position + 1);
+				if (size === void 0) return yield* storeError("rebuild work", "Canonical record byte length is missing");
+				if (bytes + size > MAX_WORK_REBUILD_BYTES) break;
+				const record = thread === void 0 ? void 0 : storedRecord(thread, position + 1);
+				if (record === void 0 || record.sequence !== position + 1) return yield* storeError("rebuild work", "Canonical rebuild sequence is incomplete");
+				bytes += size;
+				records.push(record);
+			}
+			if (index.through < tail && records.length === 0) return yield* storeError("rebuild work", "Canonical rebuild cannot advance within its byte bound");
+			const commitWork = yield* prepareWork(index, records, retainedDelivery).pipe(Effect.provideService(Crypto.Crypto, crypto));
+			const next = yield* Effect.sync(() => {
+				const native = prepareIndexes(rebuildingIndexes, records);
+				const rebuilt = commitWork();
+				const complete = rebuilt.through === tail;
+				const next = {
+					version: rebuilt.version,
+					through: rebuilt.through,
+					reporting: rebuilt.reporting,
+					entryCount: rebuilt.entryCount,
+					entries: rebuilt.entries,
+					messages: rebuilt.messages,
+					foreign: rebuilt.foreign,
+					workers: rebuilt.workers,
+					liveInputs: rebuilt.liveInputs,
+					inputsByWorker: rebuilt.inputsByWorker,
+					state: complete ? "ready" : "rebuilding",
+					...complete ? {} : { rebuildingIndexes: native.indexes }
+				};
+				native.commit();
+				if (thread !== void 0 && complete) MutableRef.set(state.ref, { threads: new Map(current.threads).set(request.threadId, {
+					...thread,
+					...native.indexes
+				}) });
+				publishWork(request.threadId, next);
+				return next;
+			});
+			return {
+				version: WORK_INDEX_VERSION,
+				threadId: request.threadId,
+				state: next.state,
+				throughSequence: next.through,
+				tailSequence: tail,
+				processedRecords: records.length,
+				processedBytes: bytes
+			};
+		}))
+	};
 	yield* Effect.addFinalizer(() => PubSub.shutdown(updates));
-	const materialize = Effect.fn("MemoryThreadStore.materialize")((unvalidated) => Effect.gen(function* () {
+	const materialize = Effect.fnUntraced(function* (unvalidated) {
 		const request = yield* validate(ThreadMaterialization, "materialize", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.threads.get(request.threadId);
-			if (existing !== void 0) {
-				if (request.producerEpoch < existing.producerEpoch) return [{
-					_tag: "failure",
-					error: FenceRejected.make({
-						threadId: request.threadId,
-						actualEpoch: existing.producerEpoch,
-						attemptedEpoch: request.producerEpoch
-					})
-				}, current];
-				if (request.producerEpoch === existing.producerEpoch) return [{ _tag: "success" }, current];
-				const threads = new Map(current.threads);
-				threads.set(request.threadId, {
-					...existing,
-					producerEpoch: request.producerEpoch
-				});
-				return [{ _tag: "success" }, { threads }];
-			}
-			if (current.threads.size >= maxThreads) return [{
+			if (current.threads.get(request.threadId) !== void 0) return [{ _tag: "success" }, current];
+			if (!MutableRef.get(workState.ref).has(request.threadId) && MutableRef.get(workState.ref).size >= maxThreads) return [{
 				_tag: "failure",
 				error: storeError("materialize", `In-memory thread limit ${maxThreads} exceeded`)
 			}, current];
+			if (!transferPageFits(request.threadId)) return [{
+				_tag: "failure",
+				error: storeError("materialize", "Thread identity exceeds its bounded transfer representation")
+			}, current];
 			const threads = new Map(current.threads);
 			threads.set(request.threadId, {
-				producerEpoch: request.producerEpoch,
 				tailSequence: ZERO_CANONICAL_SEQUENCE,
-				tailDigest: EMPTY_TAIL_DIGEST,
-				unverifiedWorkerInputs: /* @__PURE__ */ new Set(),
 				byId: /* @__PURE__ */ new Map(),
 				workerRecords: /* @__PURE__ */ new Map(),
 				peerCount: 0,
 				runInputs: /* @__PURE__ */ new Map(),
-				outstanding: /* @__PURE__ */ new Map(),
-				records: [],
-				recordIds: /* @__PURE__ */ new Set(),
+				runRecords: /* @__PURE__ */ new Map(),
+				operationRecords: /* @__PURE__ */ new Map(),
+				handoffs: [],
+				agentUpdates: [],
+				deliveryPredecessors: [],
+				toolDeclarations: /* @__PURE__ */ new Map(),
+				promptEvidence: [],
+				modelCompletions: [],
+				applicationInputs: [],
+				durableOwners: [],
+				windowBoundaries: /* @__PURE__ */ new Map(),
+				ranges: /* @__PURE__ */ new Map(),
+				rangeStarts: [],
+				archiveContents: /* @__PURE__ */ new Map(),
+				chunks: /* @__PURE__ */ new Map(),
+				batchesByFirst: /* @__PURE__ */ new Map(),
 				batches: /* @__PURE__ */ new Map(),
-				tailDigests: /* @__PURE__ */ new Map([[ZERO_CANONICAL_SEQUENCE, EMPTY_TAIL_DIGEST]]),
+				executions: /* @__PURE__ */ new Map(),
+				executionCommits: /* @__PURE__ */ new Map(),
 				checkpoints: /* @__PURE__ */ new Map()
 			});
+			publishWork(request.threadId, emptyWorkIndex());
 			return [{ _tag: "success" }, { threads }];
 		});
 		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const append = Effect.fn("MemoryThreadStore.append")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(FencedAppendRequest, "append", unvalidated);
-		const digest = yield* digestCanonicalBatch(request.expectedTailDigest, request.batch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => storeError("append", error.message, error)));
+	});
+	const prepareAppend = Effect.fnUntraced(function* (unvalidated) {
+		const captured = yield* PreparedAppend.capture(unvalidated);
+		const request = captured;
+		const batchJson = captured.batchJson;
+		const batchBytes = new TextEncoder().encode(batchJson).byteLength;
+		if (batchBytes > 16777216) return yield* storeError("append", "Canonical batch exceeds 16 MiB");
+		const offsetBytes = 4 * Math.ceil(utf8ByteLength(request.threadId) / 3) + 36;
+		if (!canonicalBatchFitsTransfer(request.threadId, request.batch, batchBytes, offsetBytes)) return yield* storeError("append", "Canonical batch exceeds its bounded transfer representation");
+		return {
+			request,
+			batchJson
+		};
+	});
+	const appendPrepared = Effect.fnUntraced(function* ({ request, batchJson }) {
+		const thread = (yield* Ref.get(state)).threads.get(request.threadId);
+		const executionIntent = JSON.stringify({
+			batch: batchJson,
+			operational: (request.executions ?? []).flatMap((update) => update.facts.map((fact) => Schema.encodeSync(RecordEnvelope)(fact)))
+		});
+		const latestIntent = thread === void 0 ? void 0 : [...thread.executionCommits.values()].find((entry) => entry.batchId === request.batch.batchId);
+		if (thread !== void 0 && latestIntent === void 0 && request.batch.records.length === 0) for (const update of request.executions ?? []) {
+			const prior = thread.executions.get(update.checkpoint.progress.runId);
+			if (prior !== void 0 && update.previousRevision < prior.progress.revision && update.facts.every((fact) => prior.operational.some((known) => known.recordId === fact.recordId))) return yield* AppendConflict.make({
+				threadId: request.threadId,
+				batchId: request.batch.batchId,
+				reason: "stale-command"
+			});
+		}
+		if (thread !== void 0 && thread.tailSequence === request.expectedTailSequence && !thread.batches.has(request.batch.batchId) && latestIntent === void 0) {
+			const executions = request.executions ?? [];
+			if (new Set(executions.map((update) => update.checkpoint.progress.runId)).size !== executions.length) return yield* storeError("append", "Duplicate active execution identity");
+			for (const update of request.executions ?? []) {
+				const prior = thread.executions.get(update.checkpoint.progress.runId);
+				if ((prior?.progress.revision ?? 0) !== update.previousRevision) return yield* AppendConflict.make({
+					threadId: request.threadId,
+					batchId: request.batch.batchId,
+					reason: "tail",
+					actualTailSequence: thread.tailSequence
+				});
+				if (update.checkpoint.throughSequence !== thread.tailSequence + request.batch.records.length || update.checkpoint.batchId !== request.batch.batchId || prior !== void 0 && update.checkpoint.originalSequence !== prior.originalSequence) return yield* storeError("append", "Active checkpoint differs from its committed history boundary");
+				if (update.retire && ![...request.batch.records, ...(thread.runRecords.get(update.checkpoint.progress.runId) ?? []).map((entry) => entry.record)].some(({ payload }) => payload._tag === "SubmissionSettled" && payload.runId === update.checkpoint.progress.runId && payload.submissionId === update.checkpoint.progress.submissionId)) return yield* storeError("append", "Active state cannot retire without a canonical terminal outcome");
+			}
+			yield* validateProgressAppend(prepareProgressAppend(request.batch.records), request.executions).pipe(Effect.provideService(ProgressAppendReader, {
+				previous: (runId) => Effect.succeed(thread.executions.get(runId)?.progress),
+				initial: (next) => Effect.succeed((thread.runRecords.get(next.runId) ?? []).map((entry) => entry.record))
+			}));
+		}
+		const currentWork = (yield* Ref.get(workState)).get(request.threadId);
+		const preparedWork = thread !== void 0 && thread.tailSequence === request.expectedTailSequence && !thread.batches.has(request.batch.batchId) && latestIntent === void 0 && currentWork?.version === WORK_INDEX_VERSION && currentWork.state === "ready" && currentWork.through === thread.tailSequence && currentWork.entryCount === currentWork.entries.size ? yield* prepareWork(currentWork, batchEnvelopes(request.threadId, request.batch, decodeCanonicalSequence(thread.tailSequence + 1)), retainedDelivery).pipe(Effect.provideService(Crypto.Crypto, crypto)) : void 0;
 		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const thread = current.threads.get(request.threadId);
 			if (thread === void 0) return [{
 				_tag: "failure",
 				error: ThreadNotMaterialized.make({ threadId: request.threadId })
 			}, current];
-			if (request.producerEpoch !== thread.producerEpoch) return [{
-				_tag: "failure",
-				error: FenceRejected.make({
-					threadId: request.threadId,
-					actualEpoch: thread.producerEpoch,
-					attemptedEpoch: request.producerEpoch
-				})
-			}, current];
+			const priorExecution = latestIntent;
+			if (priorExecution !== void 0) {
+				if (priorExecution.intent !== executionIntent) return [{
+					_tag: "failure",
+					error: AppendConflict.make({
+						threadId: request.threadId,
+						batchId: request.batch.batchId,
+						reason: "batch-content"
+					})
+				}, current];
+				return [{
+					_tag: "success",
+					result: AppendResult.make({
+						...priorExecution.result,
+						replayed: true
+					}),
+					records: []
+				}, current];
+			}
 			const previous = thread.batches.get(request.batch.batchId);
 			if (previous !== void 0) {
-				if (previous.digest !== digest) return [{
+				if (previous.batchJson !== batchJson) return [{
 					_tag: "failure",
 					error: AppendConflict.make({
 						threadId: request.threadId,
 						batchId: request.batch.batchId,
-						reason: "batch-digest"
+						reason: "batch-content"
 					})
 				}, current];
 				return [{
@@ -134,29 +674,23 @@ const makeThreadStore = Effect.gen(function* () {
 					result: AppendResult.make({
 						firstSequence: previous.result.firstSequence,
 						lastSequence: previous.result.lastSequence,
-						tailDigest: previous.result.tailDigest,
 						replayed: true
 					}),
 					records: []
 				}, current];
 			}
-			if (request.expectedTailSequence !== thread.tailSequence || request.expectedTailDigest !== thread.tailDigest) return [{
+			if (request.expectedTailSequence !== thread.tailSequence) return [{
 				_tag: "failure",
 				error: AppendConflict.make({
 					threadId: request.threadId,
 					batchId: request.batch.batchId,
 					reason: "tail",
-					actualTailSequence: thread.tailSequence,
-					actualTailDigest: thread.tailDigest
+					actualTailSequence: thread.tailSequence
 				})
 			}, current];
-			if (thread.records.length + request.batch.records.length > MAX_RECORDS_PER_THREAD) return [{
-				_tag: "failure",
-				error: storeError("append", `In-memory record limit ${MAX_RECORDS_PER_THREAD} exceeded`)
-			}, current];
 			const batchRecordIds = /* @__PURE__ */ new Set();
 			for (const record of request.batch.records) {
-				if (thread.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
+				if (thread.byId.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
 					_tag: "failure",
 					error: AppendConflict.make({
 						threadId: request.threadId,
@@ -166,186 +700,558 @@ const makeThreadStore = Effect.gen(function* () {
 				}, current];
 				batchRecordIds.add(record.recordId);
 			}
-			const records = request.batch.records.map((record, index) => {
-				const sequence = decodeCanonicalSequence(thread.tailSequence + index + 1);
-				return CanonicalRecordEnvelope.make({
-					threadId: request.threadId,
-					batchId: request.batch.batchId,
-					sequence,
-					offset: observationOffset(request.threadId, sequence),
-					record
-				});
-			});
+			const records = batchEnvelopes(request.threadId, request.batch, decodeCanonicalSequence(thread.tailSequence + 1));
 			const lastSequence = decodeCanonicalSequence(thread.tailSequence + records.length);
 			const result = AppendResult.make({
-				firstSequence: decodeCanonicalSequence(thread.tailSequence + 1),
+				firstSequence: decodeCanonicalSequence(thread.tailSequence + (records.length > 0 ? 1 : 0)),
 				lastSequence,
-				tailDigest: digest,
 				replayed: false
 			});
-			const batches = new Map(thread.batches);
-			batches.set(request.batch.batchId, {
-				digest,
-				result
-			});
-			const recordIds = new Set(thread.recordIds);
-			for (const recordId of batchRecordIds) recordIds.add(recordId);
-			const tailDigests = new Map(thread.tailDigests);
-			tailDigests.set(lastSequence, digest);
-			const threads = new Map(current.threads);
-			const unverifiedWorkerInputs = new Set(thread.unverifiedWorkerInputs);
-			let peerCount = thread.peerCount;
-			const workerRecords = new Map(thread.workerRecords);
-			const byId = new Map(thread.byId);
-			const runInputs = new Map(thread.runInputs);
-			const outstanding = new Map(thread.outstanding);
-			for (const entry of records) {
-				byId.set(entry.record.recordId, entry);
-				const payload = entry.record.payload;
-				if (payload._tag === "PeerMessagePrepared") peerCount++;
-				if ((payload._tag === "UserInputRecorded" || payload._tag === "RunStarted") && payload.runId !== void 0) workerRecords.set(`execution:${payload._tag}`, [entry]);
-				const workerKey = payload._tag === "SubtreeBudgetReserved" ? `subtree:${payload.sourceSubmissionId ?? ""}` : payload._tag === "SubagentJoined" ? `joined:${payload.runId}` : [
-					"ThreadCreated",
-					"WorkerOriginRecorded",
-					"SubagentLineageRecorded",
-					"WorkerInputRequested",
-					"WorkerInputCompleted",
-					"WorkerStopRequested"
-				].includes(payload._tag) ? "worker" : void 0;
-				if (workerKey !== void 0) workerRecords.set(workerKey, [...workerRecords.get(workerKey) ?? [], entry]);
-				if (payload._tag === "UserInputRecorded" && payload.kind === "user" && payload.runId !== void 0) runInputs.set(payload.runId, runInputs.has(payload.runId) ? null : entry);
-				if (payload._tag === "ToolCallPrepared" || payload._tag === "ToolCallUnknown" || payload._tag === "ToolCallSettled") {
-					const key = JSON.stringify([payload.runId, payload.toolCallId]);
-					if (payload._tag === "ToolCallSettled") outstanding.delete(key);
-					else outstanding.set(key, [...(outstanding.get(key) ?? []).filter((prior) => payload._tag !== "ToolCallUnknown" || prior.record.payload._tag !== "ToolCallPrepared"), entry]);
-				}
-				if (payload._tag === "WorkerInputRequested") outstanding.set(`worker:${payload.admission.messageId}`, [...outstanding.get(`worker:${payload.admission.messageId}`) ?? [], entry]);
-				if (payload._tag === "WorkerInputCompleted") {
-					if (payload.effectsResolved) {
-						outstanding.delete(`worker:${payload.messageId}`);
-						unverifiedWorkerInputs.delete(payload.messageId);
-					} else unverifiedWorkerInputs.add(payload.messageId);
+			const indexes = prepareIndexes(thread, records);
+			const next = {
+				...thread,
+				...indexes.indexes,
+				tailSequence: lastSequence
+			};
+			if (records.length > 0) {
+				thread.batches.set(request.batch.batchId, {
+					result,
+					batchJson
+				});
+				thread.batchesByFirst.set(result.firstSequence, request.batch.batchId);
+				retainRecords(thread, records);
+			}
+			for (const update of request.executions ?? []) {
+				const runId = update.checkpoint.progress.runId;
+				if (update.retire) {
+					thread.executions.delete(runId);
+					thread.executionCommits.delete(runId);
+				} else {
+					thread.executions.set(runId, update.checkpoint);
+					thread.executionCommits.set(runId, {
+						batchId: request.batch.batchId,
+						intent: executionIntent,
+						result
+					});
 				}
 			}
-			threads.set(request.threadId, {
-				...thread,
-				byId,
-				workerRecords,
-				peerCount,
-				runInputs,
-				outstanding,
-				unverifiedWorkerInputs,
-				tailSequence: lastSequence,
-				tailDigest: digest,
-				records: [...thread.records, ...records],
-				recordIds,
-				batches,
-				tailDigests
-			});
+			indexes.commit();
+			if (preparedWork !== void 0) publishWork(request.threadId, preparedWork());
+			current.threads.set(request.threadId, next);
 			return [{
 				_tag: "success",
 				result,
 				records
-			}, { threads }];
+			}, current];
 		}).pipe(Effect.tap((decision) => decision._tag === "success" && decision.records.length > 0 ? PubSub.publish(updates, void 0) : Effect.void)));
 		if (decision._tag === "failure") return yield* decision.error;
 		return decision.result;
-	}));
+	});
+	const append = Effect.fn("MemoryThreadStore.append")((request) => prepareAppend(request).pipe(Effect.flatMap((prepared) => owner.withProgress(prepared.request.threadId, withMutation(appendPrepared(prepared))))));
 	const countPeerMessages = Effect.fnUntraced(function* (request) {
 		yield* validate(ThreadPeerCountRequest, "countPeerMessages", request);
 		const thread = yield* findThread(yield* Ref.get(state), request.threadId);
-		return Math.min(thread.peerCount, request.limit);
+		const index = yield* readyIndex(request.threadId, thread.tailSequence).pipe(Effect.mapError((cause) => storeError("countPeerMessages", cause.message)));
+		return Math.min(index.foreign.peer + (deliveryTransfer?.pendingPeerCount(request.threadId, request.limit) ?? 0), request.limit);
 	});
-	const readSnapshot = Effect.fn("MemoryThreadStore.readSnapshot")((threadId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, threadId)), Effect.map((thread) => {
-		const start = afterSequence ?? ZERO_CANONICAL_SEQUENCE;
-		return thread.records.slice(start, start + limit);
-	})));
-	const read = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ThreadReadRequest, "read", unvalidated);
-		if ("selection" in request) {
-			const thread = yield* findThread(yield* Ref.get(state), request.threadId);
-			const selection = request.selection;
-			if ("expectedTailSequence" in selection && (selection.expectedTailSequence !== thread.tailSequence || selection.expectedTailDigest !== thread.tailDigest)) return yield* storeError("selected read", "Canonical tail changed");
-			let records;
-			switch (selection._tag) {
-				case "RecordId": {
-					const record = thread.byId.get(selection.recordId);
-					records = record === void 0 ? [] : [record];
-					break;
-				}
-				case "RunInput": {
-					const input = thread.runInputs.get(selection.runId);
-					if (input === null) return yield* storeError("selected read", "Ambiguous original Run input");
-					records = input === void 0 ? [] : [input];
-					break;
+	const readSnapshot = (threadId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, threadId)), Effect.map((thread) => {
+		return storedPage(thread, afterSequence ?? ZERO_CANONICAL_SEQUENCE, limit);
+	}));
+	const selectedStream = (sources, after, through, maximum) => Stream.paginate({
+		after,
+		count: 0
+	}, (cursor) => Effect.gen(function* () {
+		const page = [];
+		let bytes = 0;
+		let last = cursor.after;
+		while (page.length < Math.min(READ_PAGE_SIZE, maximum - cursor.count)) {
+			let selected;
+			for (const source of sources) {
+				const next = source[upperSequence(source, last)];
+				if (next !== void 0 && next.sequence <= through && (selected === void 0 || next.sequence < selected.sequence)) selected = next;
+			}
+			if (selected === void 0) break;
+			const size = canonicalRecordBytes(selected.record);
+			if (size > 33554432) return yield* storeError("read", "Canonical value exceeds the page byte bound");
+			if (bytes + size > 33554432) break;
+			bytes += size;
+			page.push(selected);
+			last = selected.sequence;
+		}
+		const next = {
+			after: last,
+			count: cursor.count + page.length
+		};
+		return [page, page.length === 0 || next.count >= maximum ? Option.none() : Option.some(next)];
+	}));
+	const readFromThread = (threadId, thread, request) => Stream.unwrap(Effect.gen(function* () {
+		if (request.threadId !== threadId) return yield* storeError("read snapshot", "Thread differs from the captured snapshot");
+		if (!("selection" in request)) return Stream.paginate({
+			after: request.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
+			count: 0
+		}, (cursor) => Effect.gen(function* () {
+			const page = storedPage(thread, cursor.after, Math.min(READ_PAGE_SIZE, request.limit - cursor.count));
+			const next = {
+				after: page.at(-1)?.sequence ?? cursor.after,
+				count: cursor.count + page.length
+			};
+			return [page, page.length === 0 || next.count >= request.limit ? Option.none() : Option.some(next)];
+		}));
+		const selection = request.selection;
+		if ("expectedTailSequence" in selection && selection.expectedTailSequence !== thread.tailSequence) return yield* storeError("selected read", "Canonical tail changed");
+		if ("throughSequence" in selection && selection.throughSequence > thread.tailSequence) return yield* storeError("selected read", "Captured sequence is ahead of canonical tail");
+		const through = "throughSequence" in selection ? selection.throughSequence : thread.tailSequence;
+		const after = request.page.afterSequence ?? 0;
+		let sources = [];
+		const one = (entry) => entry === void 0 || entry === null ? [] : [entry];
+		const latest = (entries) => one(entries[upperSequence(entries, through) - 1]);
+		switch (selection._tag) {
+			case "RecordId":
+				sources = [one(thread.byId.get(selection.recordId))];
+				break;
+			case "RunInput": {
+				const entry = thread.runInputs.get(selection.runId);
+				if (entry === null) return yield* storeError("selected read", "Ambiguous original Run input");
+				sources = [one(entry)];
+				break;
+			}
+			case "ToolDeclaration": {
+				const entry = thread.toolDeclarations.get(selection.settlementRecordId);
+				if (entry === null) return yield* storeError("selected read", "Ambiguous original tool declaration");
+				if (entry !== void 0) {
+					const payload = entry.record.payload;
+					if (payload._tag !== "ModelResponseRecorded" || !payload.toolOperations.some((operation) => toolCallSettledRecordId(payload.runId, payload.turn, operation.toolCallId) === selection.settlementRecordId)) return yield* storeError("selected read", "Invalid exact tool declaration pointer");
 				}
-				case "Outstanding":
-					if (thread.unverifiedWorkerInputs.size > 0) return yield* storeError("selected read", "Unverified worker acknowledgement");
-					records = [...thread.outstanding.values()].flat();
-					break;
-				case "WorkerExecution":
-					records = ["UserInputRecorded", "RunStarted"].flatMap((tag) => thread.workerRecords.get(`execution:${tag}`) ?? []);
-					break;
-				case "WorkerState": records = [
-					...thread.workerRecords.get("worker") ?? [],
-					...thread.workerRecords.get(`subtree:${selection.sourceSubmissionId ?? ""}`) ?? [],
-					...selection.sourceSubmissionId === void 0 ? [] : thread.workerRecords.get(`joined:${runIdForSubmission(selection.sourceSubmissionId)}`) ?? []
+				sources = [one(entry)];
+				break;
+			}
+			case "RunEvidence":
+				sources = [thread.runRecords.get(selection.runId) ?? [], [
+					submissionInputRecordId(selection.submissionId),
+					submissionAbortRecordId(selection.submissionId),
+					submissionSettlementRecordId(selection.submissionId)
+				].flatMap((id) => one(thread.byId.get(id))).sort((a, b) => a.sequence - b.sequence)];
+				break;
+			case "OperationEvidence":
+				sources = [
+					thread.operationRecords.get(JSON.stringify([selection.runId, selection.toolCallId])) ?? [],
+					...selection.approvalToolCallIds.flatMap((toolCallId) => toolCallId === selection.toolCallId ? [] : [thread.operationRecords.get(JSON.stringify([
+						selection.runId,
+						toolCallId,
+						"approval"
+					])) ?? []]),
+					one(thread.byId.get(selection.originRecordId))
 				];
+				break;
+			case "LastAgentUpdate":
+				sources = [latest(thread.agentUpdates)];
+				break;
+			case "DeliveryPredecessor":
+				sources = [latest(thread.deliveryPredecessors)];
+				break;
+			case "LatestModelCompleted":
+				sources = [latest(thread.modelCompletions)];
+				break;
+			case "LatestApplicationInput":
+				sources = [latest(thread.applicationInputs)];
+				break;
+			case "DurableHistoryOwner":
+				sources = [one(thread.durableOwners[0])];
+				break;
+			case "PromptEvidence":
+				sources = [thread.promptEvidence];
+				break;
+			case "WorkHandoffs":
+				sources = [thread.handoffs];
+				break;
+			case "ContextWindowBoundary": {
+				let start = 0;
+				let selected;
+				while (start < selection.atSequence) {
+					const remaining = selection.atSequence - start;
+					let height = Math.floor(Math.log2(remaining));
+					while (2 ** height > remaining) height--;
+					const width = 2 ** height;
+					const entries = thread.windowBoundaries.get(`${height}:${start / width}`) ?? [];
+					const candidate = entries[upperSequence(entries, through) - 1];
+					if (candidate !== void 0 && (selected === void 0 || candidate.sequence > selected.sequence)) selected = candidate;
+					start += width;
+				}
+				sources = [one(selected)];
+				break;
+			}
+			case "WorkerStop":
+				sources = [latest(thread.workerRecords.get(`stop:${selection.workerThreadId}`) ?? [])];
+				break;
+			case "WorkerExecution":
+				sources = [thread.workerRecords.get("execution:UserInputRecorded") ?? [], thread.workerRecords.get("execution:SubmissionSettled") ?? []];
+				break;
+			case "WorkerState":
+				sources = [thread.workerRecords.get("worker") ?? [], ...selection.sourceSubmissionId === void 0 ? [] : [
+					thread.workerRecords.get(`subtree:${selection.sourceSubmissionId}`) ?? [],
+					thread.workerRecords.get(`joined:${runIdForSubmission(selection.sourceSubmissionId)}`) ?? [],
+					thread.workerRecords.get(`funding:${selection.sourceSubmissionId}`) ?? []
+				]];
+				break;
+			case "LiveWorkerInputs": {
+				const index = yield* readyIndex(request.threadId, thread.tailSequence).pipe(Effect.mapError((e) => storeError("selected read", e.message)));
+				if (selection.throughSequence !== thread.tailSequence) return yield* storeError("selected read", "Live work requires the current exact tail");
+				const locators = selection.workerThreadId === void 0 ? index.liveInputs : index.inputsByWorker.get(selection.workerThreadId) ?? [];
+				const start = liveInputPosition(locators, after + 1);
+				const selected = [];
+				for (let at = start; at < Math.min(locators.length, start + request.page.limit); at++) {
+					const entry = index.entries.get(locators[at].id);
+					const origin = entry === void 0 ? void 0 : thread.byId.get(entry.originRecordId);
+					if (entry?.owner._tag !== "WorkerInput" || origin?.record.payload._tag !== "WorkerInputRequested" || origin.sequence !== locators[at].sequence || origin.record.payload.admission.origin.worker.threadId !== entry.owner.workerThreadId || origin.record.payload.admission.reportKind === "update" !== entry.owner.update) return yield* storeError("selected read", "Invalid live worker input locator or origin");
+					selected.push(origin);
+				}
+				sources = [selected];
+				break;
 			}
-			return Stream.fromIterable(records.filter((entry) => entry.sequence > (request.page.afterSequence ?? 0)).sort((a, b) => a.sequence - b.sequence).slice(0, request.page.limit));
 		}
-		const records = yield* readSnapshot(request.threadId, request.afterSequence, request.limit);
+		return selectedStream(sources, after, through, request.page.limit);
+	}));
+	const read = (input) => Stream.unwrap(Effect.gen(function* () {
+		const request = yield* validate(ThreadReadRequest, "read", input);
+		const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+		return readFromThread(request.threadId, thread, request);
+	}));
+	const decodePromptRecord = Schema.decodeUnknownEffect(PromptRecord);
+	const readPrompt = (input) => Stream.unwrap(Effect.gen(function* () {
+		const request = yield* validate(ThreadPromptRead, "readPrompt", input);
+		const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+		if (request.throughSequence > thread.tailSequence) return yield* storeError("readPrompt", "Captured sequence is ahead of canonical tail");
+		const start = upperSequence(thread.promptEvidence, request.afterSequence ?? 0);
+		const records = [];
+		for (let at = start; at < Math.min(thread.promptEvidence.length, start + request.limit); at++) {
+			const entry = thread.promptEvidence[at];
+			if (entry.sequence > request.throughSequence) break;
+			const record = yield* decodePromptRecord(entry.record instanceof ExportedRecord ? entry.record.wire : entry.record).pipe(Effect.mapError((cause) => storeError("readPrompt", "Invalid prompt record", cause)));
+			records.push({
+				threadId: request.threadId,
+				sequence: entry.sequence,
+				record
+			});
+		}
 		return Stream.fromIterable(records);
 	}));
 	const observe = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
 		const request = yield* validate(ThreadObservation, "observe", unvalidated);
-		const afterSequence = yield* offsetSequence(request.threadId, request.afterOffset);
-		return Stream.unwrap(Effect.gen(function* () {
-			const subscription = yield* PubSub.subscribe(updates);
-			const initial = yield* readSnapshot(request.threadId, afterSequence, MAX_RECORDS_PER_THREAD);
-			const highWater = initial.length === 0 ? afterSequence : initial.at(-1)?.sequence ?? afterSequence;
-			const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.mapAccumEffect(() => highWater, (lastSequence) => readSnapshot(request.threadId, lastSequence, MAX_RECORDS_PER_THREAD).pipe(Effect.map((records) => [records.at(-1)?.sequence ?? lastSequence, records]))));
-			return Stream.fromIterable(initial).pipe(Stream.concat(live));
-		}));
-	}));
-	const exportThread = Effect.fn("MemoryThreadStore.export")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ThreadExportRequest, "export", unvalidated);
-		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
-		return ThreadExport.make({
-			format: "effect-agent/thread@1",
-			threadId: request.threadId,
-			tailSequence: thread.tailSequence,
-			tailDigest: thread.tailDigest,
-			records: thread.records
-		});
+		let after = yield* offsetSequence(request.threadId, request.afterOffset);
+		const subscription = yield* PubSub.subscribe(updates);
+		const drain = () => Stream.paginate(after, (cursor) => readSnapshot(request.threadId, cursor, READ_PAGE_SIZE).pipe(Effect.map((records) => {
+			after = records.at(-1)?.sequence ?? cursor;
+			return [records, records.length > 0 ? Option.some(after) : Option.none()];
+		})));
+		return drain().pipe(Stream.concat(Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.flatMap(drain))));
 	}));
-	const inspectTail = Effect.fn("MemoryThreadStore.inspectTail")((unvalidated) => Effect.gen(function* () {
+	const emptyThread = () => ({
+		...emptyIndexes(),
+		tailSequence: ZERO_CANONICAL_SEQUENCE,
+		ranges: /* @__PURE__ */ new Map(),
+		rangeStarts: [],
+		archiveContents: /* @__PURE__ */ new Map(),
+		chunks: /* @__PURE__ */ new Map(),
+		batches: /* @__PURE__ */ new Map(),
+		executions: /* @__PURE__ */ new Map(),
+		executionCommits: /* @__PURE__ */ new Map(),
+		batchesByFirst: /* @__PURE__ */ new Map(),
+		checkpoints: /* @__PURE__ */ new Map()
+	});
+	const makeExportReader = (idleOnly) => ThreadExporterReader.of({
+		snapshot: Effect.fnUntraced(function* (threadId, captured) {
+			const thread = MutableRef.get(state.ref).threads.get(threadId);
+			const facts = ledgerTransfer === void 0 ? {
+				idle: true,
+				admissions: 0,
+				aborts: 0,
+				approvals: 0,
+				resolutions: 0
+			} : yield* ledgerTransfer.snapshot(threadId);
+			const delivered = deliveryTransfer?.snapshot(threadId) ?? {
+				idle: true,
+				deliveries: 0
+			};
+			if (thread === void 0 && facts.admissions === 0 && delivered.deliveries === 0) return yield* ThreadNotMaterialized.make({ threadId });
+			if (idleOnly) {
+				const index = yield* readyIndex(threadId, thread?.tailSequence ?? 0).pipe(Effect.mapError((e) => storeError("export", e.message)));
+				if (owner.hasOwner(threadId) || (thread?.executions.size ?? 0) > 0 || index.entries.size > 0 || !facts.idle || !delivered.idle) return yield* ThreadExportRejected.make({
+					threadId,
+					reason: "non-idle"
+				});
+				if (captured === void 0 && thread !== void 0) yield* Effect.gen(function* () {
+					for (const runId of thread.runRecords.keys()) yield* validateClosedRun(threadId, Schema.decodeSync(RunId)(runId));
+					if (ledgerTransfer !== void 0) {
+						const ledger = ledgerTransfer;
+						yield* Stream.runForEach(ledger.submissions(threadId), (submission) => Effect.gen(function* () {
+							const admission = yield* ledger.admission(threadId, submission.submissionId);
+							if (admission === void 0) return yield* storeError("export", "Missing immutable admission");
+							yield* rebuildClosedSubmission(admission);
+						}));
+					}
+				}).pipe(Effect.provide(ThreadImportReader.layer(importReader(threadId, thread))), Effect.mapError((cause) => Schema.is(ThreadImportRejected)(cause) ? ThreadExportRejected.make({
+					threadId,
+					reason: "non-idle"
+				}) : cause));
+			}
+			return {
+				format: CURRENT_RECORD_FORMAT,
+				threadId,
+				tailSequence: thread?.tailSequence ?? ZERO_CANONICAL_SEQUENCE,
+				snapshot: {
+					admissions: facts.admissions,
+					aborts: facts.aborts,
+					approvals: facts.approvals,
+					resolutions: facts.resolutions,
+					deliveries: delivered.deliveries
+				},
+				...facts.workerSeal === void 0 ? {} : { workerSeal: facts.workerSeal }
+			};
+		}),
+		batch: Effect.fnUntraced(function* (threadId, fromSequence) {
+			const thread = yield* findThread(MutableRef.get(state.ref), threadId);
+			const batchId = thread.batchesByFirst.get(fromSequence);
+			const stored = batchId === void 0 ? void 0 : thread.batches.get(batchId);
+			if (stored === void 0 || new TextEncoder().encode(stored.batchJson).byteLength > 16777216) return yield* storeError("export", "Missing or oversized canonical batch wire");
+			const batch = yield* decodeStoredBatch(stored.batchJson, "export");
+			const records = [];
+			for (const [index, record] of batch.records.entries()) {
+				const sequence = decodeCanonicalSequence(fromSequence + index);
+				const exact = storedRecord(thread, sequence);
+				if (exact === void 0 || exact.batchId !== batch.batchId || exact.record.recordId !== record.recordId) return yield* storeError("export", "Canonical batch index differs from its wire");
+				records.push(ThreadExportRecord.make({
+					threadId,
+					batchId: batch.batchId,
+					sequence,
+					offset: observationOffset(threadId, sequence),
+					record
+				}));
+			}
+			return {
+				batches: [{
+					batchId: batch.batchId,
+					producerId: batch.producerId
+				}],
+				records
+			};
+		}),
+		facts: (threadId, section, after) => {
+			const empty = Effect.succeed({
+				facts: {
+					admissions: [],
+					commands: {
+						aborts: [],
+						approvals: [],
+						resolutions: []
+					},
+					deliveries: []
+				},
+				after: after ?? ""
+			});
+			return section === "deliveries" ? deliveryTransfer?.facts(threadId, after) ?? empty : ledgerTransfer?.facts(threadId, section, after) ?? empty;
+		}
+	});
+	const exportReader = makeExportReader(true);
+	const verificationReader = makeExportReader(false);
+	const exportThread = (request) => exportThreadPage(request).pipe(Effect.provideService(ThreadExporterReader, exportReader));
+	const verificationPage = (request) => exportThreadPage(request).pipe(Effect.provideService(ThreadExporterReader, verificationReader));
+	const exactRunRecords = (thread, runId) => Effect.gen(function* () {
+		const records = [];
+		let bytes = 0;
+		const facts = thread.runRecords.get(runId) ?? [];
+		if (facts.length > MAX_RUN_EVIDENCE_RECORDS + RUN_TERMINAL_RESERVE_RECORDS + MAX_RUN_RECOVERY_SUFFIX_RECORDS) return yield* storeError("Run evidence", "Run record bounds exceeded");
+		for (const entry of facts) {
+			bytes += canonicalRecordBytes(entry.record);
+			if (bytes > MAX_RUN_EVIDENCE_BYTES + MAX_RUN_TERMINAL_BYTES + MAX_RUN_RECOVERY_SUFFIX_BYTES) return yield* storeError("Run evidence", "Run byte bounds exceeded");
+			records.push(entry);
+		}
+		return records.sort((a, b) => a.sequence - b.sequence);
+	});
+	const exactRecordReader = (threadId, thread) => ({
+		read: (input) => Stream.unwrap(validate(ThreadReadRequest, "read snapshot", input).pipe(Effect.map((request) => readFromThread(threadId, thread, request)))),
+		record: (id) => Effect.succeed(thread.byId.get(id)),
+		runRecords: (id) => exactRunRecords(thread, id),
+		execution: (id) => Effect.succeed(thread.executions.get(id)),
+		hasAgent: (id) => Effect.succeed((thread.workerRecords.get("worker") ?? []).some(({ record }) => record.payload._tag === "ThreadCreated" && record.payload.agentId === id))
+	});
+	const importReader = (id, thread) => ({
+		...exactRecordReader(id, thread),
+		admission: (sid) => ledgerTransfer?.admission(id, sid) ?? Effect.succeed(void 0),
+		runOwner: (runId) => runId.startsWith("run:") ? ledgerTransfer?.admission(id, Schema.decodeSync(SubmissionId)(runId.slice(4))) ?? Effect.succeed(void 0) : Effect.succeed(void 0),
+		commands: (sid) => ledgerTransfer?.commands(sid) ?? Effect.succeed({
+			aborts: [],
+			approvals: [],
+			resolutions: []
+		}),
+		delivery: (messageId) => deliveryTransfer?.record(id, messageId) ?? Effect.succeed(void 0)
+	});
+	const importThread = (pages) => captureImportSource(pages, (captured) => withMutation(Effect.gen(function* () {
+		const progress = makeThreadImportProgress();
+		let staged;
+		let stagedWork = emptyWorkIndex();
+		let stagedLedger;
+		let stagedDelivery;
+		let existing;
+		yield* Stream.runForEach(captured, (input) => Effect.gen(function* () {
+			const page = yield* prepareImportPage(progress, input).pipe(Effect.provideService(Crypto.Crypto, crypto));
+			const id = page.archive.threadId;
+			if (staged === void 0) {
+				existing = MutableRef.get(state.ref).threads.get(id);
+				const existingWork = MutableRef.get(workState.ref).get(id);
+				if (existing !== void 0 && (existing.tailSequence > 0 || existing.batches.size > 0 || existing.executions.size > 0 || existing.executionCommits.size > 0 || existing.checkpoints.size > 0 || existing.ranges.size > 0 || existing.archiveContents.size > 0) || existingWork !== void 0 && (existingWork.entries.size > 0 || existingWork.state !== "ready" || existingWork.through !== 0)) return yield* ThreadImportRejected.make({
+					threadId: id,
+					reason: "target-not-empty",
+					message: "Destination canonical Thread is not empty"
+				});
+				if (!MutableRef.get(workState.ref).has(id) && MutableRef.get(workState.ref).size >= maxThreads) return yield* storeError("import", "Destination Thread capacity exceeded");
+				staged = emptyThread();
+				stagedLedger = ledgerTransfer === void 0 ? void 0 : yield* ledgerTransfer.startImport(id);
+				stagedDelivery = deliveryTransfer === void 0 ? void 0 : yield* deliveryTransfer.startImport(id);
+				if (page.archive.workerSeal !== void 0 && stagedLedger === void 0) return yield* ThreadImportRejected.make({
+					threadId: id,
+					reason: "unsupported-obligations",
+					message: "A paired ledger is required to preserve the worker seal"
+				});
+			}
+			if (page.archive.admissions.length > 0 && stagedLedger === void 0) return yield* ThreadImportRejected.make({
+				threadId: id,
+				reason: "unsupported-obligations",
+				message: "A paired ledger is required for admission restore"
+			});
+			if (page.archive.deliveries.length > 0 && stagedDelivery === void 0) return yield* ThreadImportRejected.make({
+				threadId: id,
+				reason: "unsupported-obligations",
+				message: "A paired delivery store is required for delivery restore"
+			});
+			for (const batch of page.batches) {
+				if (!canonicalBatchFitsTransfer(id, batch.batch, utf8ByteLength(batch.batchJson), 4 * Math.ceil(utf8ByteLength(id) / 3) + 36)) return yield* ThreadImportRejected.make({
+					threadId: id,
+					reason: "unsupported-capacity",
+					message: "Canonical batch exceeds its bounded transfer representation"
+				});
+				if (staged.batches.has(batch.batch.batchId)) return yield* invalidThreadArchive("Duplicate canonical batch identity", id);
+				const records = page.records.filter((entry) => entry.batchId === batch.batch.batchId).map((entry) => CanonicalRecordEnvelope.make({
+					...entry,
+					offset: observationOffset(id, entry.sequence)
+				}));
+				for (const entry of records) if (staged.byId.has(entry.record.recordId)) return yield* invalidThreadArchive("Duplicate canonical record identity", id);
+				const native = prepareIndexes(staged, records);
+				const commitWork = yield* prepareWork(stagedWork, records, (_, messageId) => stagedDelivery?.has(messageId) ?? false).pipe(Effect.provideService(Crypto.Crypto, crypto));
+				retainRecords(staged, records);
+				native.commit();
+				staged = {
+					...staged,
+					...native.indexes,
+					tailSequence: batch.lastSequence
+				};
+				staged.batches.set(batch.batch.batchId, {
+					batchJson: batch.batchJson,
+					result: AppendResult.make({
+						firstSequence: batch.firstSequence,
+						lastSequence: batch.lastSequence,
+						replayed: false
+					})
+				});
+				staged.batchesByFirst.set(batch.firstSequence, batch.batch.batchId);
+				stagedWork = commitWork();
+			}
+			if (stagedLedger !== void 0) yield* stagedLedger.stage(page);
+			if (stagedDelivery !== void 0) yield* stagedDelivery.stage(page);
+			for (const delivery of page.archive.deliveries) {
+				for (const workId of stagedWork.messages.get(delivery.key.messageId) ?? []) {
+					const entry = stagedWork.entries.get(workId);
+					if (entry !== void 0) changeWorkCounts(stagedWork, entry, -1);
+					stagedWork.entries.delete(workId);
+				}
+				stagedWork.messages.delete(delivery.key.messageId);
+				stagedWork = {
+					...stagedWork,
+					entryCount: stagedWork.entries.size
+				};
+			}
+		}));
+		const result = yield* finishThreadImport(progress);
+		if (staged === void 0) return yield* invalidThreadArchive("Missing transfer pages");
+		const restoredThread = staged;
+		const id = result.threadId;
+		const fallback = {
+			admission: () => Effect.succeed(void 0),
+			runOwner: () => Effect.succeed(void 0),
+			commands: () => Effect.succeed({
+				aborts: [],
+				approvals: [],
+				resolutions: []
+			})
+		};
+		const reader = {
+			...exactRecordReader(id, restoredThread),
+			...stagedLedger?.reader ?? fallback,
+			delivery: stagedDelivery?.record ?? (() => Effect.succeed(void 0))
+		};
+		return yield* Effect.gen(function* () {
+			for (const runId of restoredThread.runRecords.keys()) {
+				yield* verifyRunContinuations(yield* reader.runRecords(Schema.decodeSync(RunId)(runId)), { verifyContext: false }).pipe(Effect.mapError((e) => invalidThreadArchive(e.message, id)));
+				yield* validateClosedRun(id, Schema.decodeSync(RunId)(runId));
+			}
+			let lastInputQueue = -1;
+			for (let sequence = 1; sequence <= restoredThread.tailSequence; sequence++) {
+				const entry = storedRecord(restoredThread, sequence);
+				if (entry === void 0) return yield* invalidThreadArchive("Incomplete canonical staging", id);
+				yield* verifyImportedReferences(entry);
+				const payload = entry.record.payload;
+				if (payload._tag === "UserInputRecorded" && payload.submissionId !== void 0) {
+					const admission = yield* reader.admission(payload.submissionId);
+					if (admission === void 0 || admission.queueSequence <= lastInputQueue) return yield* invalidThreadArchive("Canonical inputs violate immutable admission order", id);
+					lastInputQueue = admission.queueSequence;
+				}
+				if (payload._tag === "UserInputRecorded" && payload.submissionId !== void 0 && entry.record.recordId !== submissionInputRecordId(payload.submissionId)) return yield* invalidThreadArchive("Canonical input identity is ambiguous", id);
+				if (payload._tag === "SubmissionSettled" && entry.record.recordId !== submissionSettlementRecordId(payload.submissionId)) return yield* invalidThreadArchive("Canonical settlement identity is ambiguous", id);
+				if (payload._tag !== "WorkerInputCompleted" && "submissionId" in payload && payload.submissionId !== void 0 && (yield* reader.admission(payload.submissionId)) === void 0) return yield* invalidThreadArchive("Canonical submission has no admission", id);
+			}
+			if (stagedWork.entries.size > 0) return yield* ThreadImportRejected.make({
+				threadId: id,
+				reason: "unsupported-obligations",
+				message: "Transfer contains unresolved work"
+			});
+			const commitLedger = stagedLedger === void 0 ? void 0 : yield* stagedLedger.prepareCommit(progress.manifest?.workerSeal);
+			const commitDelivery = stagedDelivery === void 0 ? void 0 : yield* stagedDelivery.prepareCommit();
+			const installed = restoredThread;
+			yield* Effect.uninterruptible(Effect.sync(() => {
+				commitLedger?.();
+				commitDelivery?.();
+				publishWork(id, stagedWork);
+				MutableRef.get(state.ref).threads.set(id, installed);
+			}).pipe(Effect.andThen(PubSub.publish(updates, void 0))));
+			return result;
+		}).pipe(Effect.provide(ThreadImportReader.layer(reader)), Effect.provideService(ThreadDeliveryImportReader, {
+			admission: (threadId, sid) => threadId === id ? reader.admission(sid) : ledgerTransfer?.admission(threadId, sid) ?? Effect.succeed(void 0),
+			record: (threadId, recordId) => Effect.succeed(threadId === id ? restoredThread.byId.get(recordId)?.record : MutableRef.get(state.ref).threads.get(threadId)?.byId.get(recordId)?.record)
+		}));
+	}).pipe(Effect.provideService(Crypto.Crypto, crypto))));
+	const inspectTail = Effect.fnUntraced(function* (unvalidated) {
 		const request = yield* validate(ThreadTailRequest, "inspectTail", unvalidated);
 		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
 		return ThreadTail.make({
 			threadId: request.threadId,
-			tailSequence: thread.tailSequence,
-			tailDigest: thread.tailDigest,
-			producerEpoch: thread.producerEpoch
+			tailSequence: thread.tailSequence
 		});
-	}));
-	const readIdentity = Effect.fn("MemoryThreadStore.readIdentity")(function* (unvalidated) {
+	});
+	const readIdentity = Effect.fnUntraced(function* (unvalidated) {
 		const request = yield* validate(ThreadIdentityRequest, "readIdentity", unvalidated);
 		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
 		const selected = [
-			thread.records[0],
+			storedRecord(thread, 1),
 			thread.byId.get(workerOriginRecordId(request.threadId)),
 			thread.byId.get(subagentLineageRecordId(request.threadId))
 		].filter((entry) => entry !== void 0);
 		return yield* ThreadIdentity.makeEffect({
 			threadId: request.threadId,
 			tailSequence: thread.tailSequence,
-			tailDigest: thread.tailDigest,
-			producerEpoch: thread.producerEpoch,
+			hasAdmissions: ledgerTransfer !== void 0 && (yield* ledgerTransfer.snapshot(request.threadId)).admissions > 0,
 			records: selected.filter((entry, index) => selected.findIndex((other) => other.record.recordId === entry.record.recordId) === index)
 		}).pipe(Effect.mapError((cause) => storeError("readIdentity", "Invalid canonical identity", cause)));
 	});
-	const saveCheckpoint = Effect.fn("MemoryThreadStore.saveCheckpoint")((unvalidated) => Effect.gen(function* () {
+	const saveCheckpoint = Effect.fnUntraced(function* (unvalidated) {
 		yield* validateCheckpointVersion(unvalidated);
 		const request = yield* validate(SaveCheckpointRequest, "saveCheckpoint", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
@@ -362,116 +1268,258 @@ const makeThreadStore = Effect.gen(function* () {
 					reason: "ahead-of-tail"
 				})
 			}, current];
-			if (thread.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
+			if (!isBatchBoundary(thread, checkpoint.throughSequence)) return [{
 				_tag: "failure",
 				error: CheckpointRejected.make({
 					threadId: checkpoint.threadId,
-					reason: "digest-mismatch"
+					reason: "not-batch-boundary"
 				})
 			}, current];
-			if (!thread.checkpoints.has(checkpoint.throughSequence) && thread.checkpoints.size >= MAX_CHECKPOINTS_PER_THREAD) return [{
-				_tag: "failure",
-				error: storeError("saveCheckpoint", `In-memory checkpoint limit ${MAX_CHECKPOINTS_PER_THREAD} exceeded`)
-			}, current];
-			const checkpoints = new Map(thread.checkpoints);
+			const checkpoints = thread.checkpoints;
 			checkpoints.set(checkpoint.throughSequence, checkpoint);
-			const threads = new Map(current.threads);
-			threads.set(checkpoint.threadId, {
-				...thread,
-				checkpoints
-			});
-			return [{ _tag: "success" }, { threads }];
+			if (checkpoints.size > MAX_CHECKPOINTS_PER_THREAD) {
+				let oldest = checkpoint.throughSequence;
+				for (const sequence of checkpoints.keys()) if (sequence < oldest) oldest = sequence;
+				checkpoints.delete(oldest);
+			}
+			return [{ _tag: "success" }, current];
 		});
 		if (decision._tag === "failure") return yield* decision.error;
-	}));
-	const loadCheckpoint = Effect.fn("MemoryThreadStore.loadCheckpoint")((unvalidated) => Effect.gen(function* () {
+	});
+	const loadCheckpoint = Effect.fnUntraced(function* (unvalidated) {
 		const request = yield* validate(LoadCheckpointRequest, "loadCheckpoint", unvalidated);
 		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
 		const maximum = request.atOrBeforeSequence ?? thread.tailSequence;
 		let selected;
 		for (const [sequence, checkpoint] of thread.checkpoints) if (sequence <= maximum && (selected === void 0 || sequence > selected.throughSequence)) selected = checkpoint;
-		if (selected !== void 0 && thread.tailDigests.get(selected.throughSequence) !== selected.tailDigest) return yield* CheckpointRejected.make({
+		if (selected !== void 0 && !isBatchBoundary(thread, selected.throughSequence)) return yield* CheckpointRejected.make({
 			threadId: request.threadId,
-			reason: "digest-mismatch"
+			reason: "not-batch-boundary"
 		});
 		return Option.fromNullishOr(selected);
-	}));
-	const saveRecoveryCheckpoint = Effect.fn("MemoryThreadStore.saveRecoveryCheckpoint")(function* (unvalidated) {
-		const request = yield* validate(SaveRecoveryCheckpointRequest, "saveRecoveryCheckpoint", unvalidated);
-		const decision = yield* Ref.modify(state, (current) => {
-			const checkpoint = request.checkpoint;
-			const thread = current.threads.get(checkpoint.threadId);
-			if (thread === void 0) return [{
-				_tag: "failure",
-				error: ThreadNotMaterialized.make({ threadId: checkpoint.threadId })
-			}, current];
-			if (thread.producerEpoch !== request.producerEpoch) return [{
-				_tag: "failure",
-				error: FenceRejected.make({
-					threadId: checkpoint.threadId,
-					actualEpoch: thread.producerEpoch,
-					attemptedEpoch: request.producerEpoch
-				})
-			}, current];
-			if (checkpoint.throughSequence > thread.tailSequence) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					threadId: checkpoint.threadId,
-					reason: "ahead-of-tail"
-				})
-			}, current];
-			if (thread.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
-				_tag: "failure",
-				error: CheckpointRejected.make({
-					threadId: checkpoint.threadId,
-					reason: "digest-mismatch"
-				})
-			}, current];
-			if ((thread.recoveryCheckpoint?.throughSequence ?? -1) > checkpoint.throughSequence) return [{ _tag: "success" }, current];
-			const threads = new Map(current.threads);
-			threads.set(checkpoint.threadId, {
-				...thread,
-				recoveryCheckpoint: checkpoint
-			});
-			return [{ _tag: "success" }, { threads }];
-		});
-		if (decision._tag === "failure") return yield* decision.error;
 	});
-	const loadRecoveryCheckpoint = Effect.fn("MemoryThreadStore.loadRecoveryCheckpoint")(function* (unvalidated) {
-		const request = yield* validate(LoadCheckpointRequest, "loadRecoveryCheckpoint", unvalidated);
-		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
-		const checkpoint = thread.recoveryCheckpoint;
-		if (checkpoint === void 0 || checkpoint.throughSequence > (request.atOrBeforeSequence ?? thread.tailSequence)) return Option.none();
-		if (thread.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
+	const verifyRange = Effect.fnUntraced(function* (thread, range, source) {
+		let sequence = range.firstSequence;
+		let bytes = 0;
+		let batches = 0;
+		const captured = /* @__PURE__ */ new Map();
+		while (sequence <= range.lastSequence) {
+			const id = thread.batchesByFirst.get(sequence);
+			const batch = id === void 0 ? void 0 : thread.batches.get(id);
+			const text = id === void 0 ? void 0 : source === void 0 ? batch?.batchJson : source.get(id);
+			if (id === void 0 || batch === void 0 || text === void 0 || batch.result.lastSequence > range.lastSequence) return yield* storeError("verify range", "Incomplete canonical batch range");
+			bytes += new TextEncoder().encode(text).byteLength;
+			batches++;
+			if (bytes > MAX_ARCHIVE_RANGE_BYTES || batches > MAX_ARCHIVE_RANGE_RECORDS || text !== batch.batchJson) return yield* storeError("verify range", "Range wire or bounds differ from canonical storage");
+			const wire = yield* Schema.decodeEffect(Schema.fromJsonString(ExportBatch))(text).pipe(Effect.mapError((cause) => storeError("verify range", "Invalid range wire", cause)));
+			if (wire.batchId !== id || batch.result.firstSequence !== sequence || batch.result.lastSequence !== sequence + wire.records.length - 1) return yield* storeError("verify range", "Canonical batch span or identity differs");
+			for (const [index, record] of wire.records.entries()) {
+				const expected = storedRecord(thread, sequence + index);
+				if (expected === void 0 || expected.threadId !== range.threadId || expected.sequence !== sequence + index || expected.batchId !== id || expected.record.recordId !== record.recordId) return yield* storeError("verify range", "Canonical record identity or order differs");
+				const canonical = yield* Schema.encodeEffect(ReadRecord)(expected.record).pipe(Effect.mapError((cause) => storeError("verify range", "Invalid canonical record", cause)));
+				const archived = yield* Schema.encodeEffect(ExportRecord)(record).pipe(Effect.mapError((cause) => storeError("verify range", "Invalid archive record", cause)));
+				if (canonicalJson(canonical) !== canonicalJson(archived)) return yield* storeError("verify range", "Archive and canonical record bytes differ");
+			}
+			captured.set(id, text);
+			sequence = decodeCanonicalSequence(batch.result.lastSequence + 1);
+		}
+		if (bytes !== range.byteCount || batches !== range.batchCount || range.recordCount !== range.lastSequence - range.firstSequence + 1) return yield* storeError("verify range", "Range spans or counts differ");
+		return captured;
+	});
+	const archiveTarget = Effect.fnUntraced(function* (request) {
+		return yield* findThread(MutableRef.get(state.ref), request.threadId);
+	});
+	const archives = {
+		page: Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ThreadArchiveRangeRead, "range page", unvalidated);
+			const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+			let low = 0;
+			let high = thread.rangeStarts.length;
+			while (low < high) {
+				const middle = Math.floor((low + high) / 2);
+				const range = thread.ranges.get(thread.rangeStarts[middle]);
+				if (range === void 0) return yield* storeError("page ranges", "Range locator has no exact range");
+				if (range.lastSequence <= (request.afterSequence ?? 0)) low = middle + 1;
+				else high = middle;
+			}
+			const ranges = [];
+			const limit = request.limit ?? 32;
+			for (let at = low; at < Math.min(thread.rangeStarts.length, low + limit); at++) {
+				const range = thread.ranges.get(thread.rangeStarts[at]);
+				if (range === void 0) return yield* storeError("page ranges", "Range locator has no exact range");
+				ranges.push(range);
+			}
+			const afterSequence = low + ranges.length < thread.rangeStarts.length ? ranges.at(-1)?.lastSequence : void 0;
+			return {
+				ranges,
+				...afterSequence === void 0 ? {} : { afterSequence }
+			};
+		}),
+		seal: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(ThreadArchiveRangeSeal, "seal range", unvalidated);
+			const thread = yield* archiveTarget(request);
+			const previousStart = thread.rangeStarts.at(-1);
+			const previous = previousStart === void 0 ? void 0 : thread.ranges.get(previousStart);
+			if (previousStart !== void 0 && previous === void 0) return yield* storeError("seal range", "Range locator has no exact range");
+			const firstSequence = (previous?.lastSequence ?? 0) + 1;
+			if (firstSequence > thread.tailSequence) return Option.none();
+			let nextSequence = firstSequence;
+			let byteCount = 0;
+			let batchCount = 0;
+			while (nextSequence <= thread.tailSequence) {
+				const batchId = thread.batchesByFirst.get(nextSequence);
+				const batch = batchId === void 0 ? void 0 : thread.batches.get(batchId);
+				if (batch === void 0) return yield* storeError("seal range", "Missing exact canonical batch");
+				const bytes = utf8ByteLength(batch.batchJson);
+				if (batchCount > 0 && (batch.result.lastSequence - firstSequence + 1 > MAX_ARCHIVE_RANGE_RECORDS || byteCount + bytes > MAX_ARCHIVE_RANGE_BYTES)) break;
+				byteCount += bytes;
+				batchCount++;
+				nextSequence = batch.result.lastSequence + 1;
+			}
+			const range = ThreadArchiveRange.make({
+				format: "effect-agent/thread-range@2",
+				threadId: request.threadId,
+				firstSequence: decodeCanonicalSequence(firstSequence),
+				lastSequence: decodeCanonicalSequence(nextSequence - 1),
+				recordCount: nextSequence - firstSequence,
+				batchCount,
+				byteCount,
+				state: "sealed"
+			});
+			yield* verifyRange(thread, range);
+			thread.ranges.set(firstSequence, range);
+			thread.rangeStarts.push(firstSequence);
+			return Option.some(range);
+		})),
+		verify: Effect.fnUntraced(function* (unvalidated) {
+			const request = yield* validate(ThreadArchiveRangeRequest, "verify range", unvalidated);
+			const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+			const range = thread.ranges.get(request.firstSequence);
+			if (range === void 0) return yield* storeError("verify range", "Unknown sealed range");
+			yield* verifyRange(thread, range, range.state === "archived" ? thread.archiveContents.get(range.firstSequence) : void 0);
+			if (range.state === "archived" && !thread.archiveContents.has(range.firstSequence)) return yield* storeError("verify range", "Published archive contents are missing");
+			return range;
+		}),
+		archive: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(ThreadArchiveRangePublish, "archive range", unvalidated);
+			const thread = yield* archiveTarget(request);
+			const range = thread.ranges.get(request.firstSequence);
+			if (range === void 0) return yield* storeError("archive range", "Unknown sealed range");
+			if (range.state === "archived") {
+				const contents = thread.archiveContents.get(range.firstSequence);
+				if (contents === void 0) return yield* storeError("archive range", "Published archive contents are missing");
+				yield* verifyRange(thread, range, contents);
+				return range;
+			}
+			const contents = yield* verifyRange(thread, range);
+			yield* verifyRange(thread, range, contents);
+			const published = ThreadArchiveRange.make({
+				...range,
+				state: "archived",
+				locator: `memory:${encodeURIComponent(request.threadId)}:${range.firstSequence}`
+			});
+			thread.archiveContents.set(range.firstSequence, contents);
+			thread.ranges.set(range.firstSequence, published);
+			return published;
+		}))
+	};
+	const readWorkerCapacity = Effect.fnUntraced(function* (unvalidated) {
+		const request = yield* validate(ThreadWorkerCapacityRequest, "worker capacity", unvalidated);
+		const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+		if (request.expectedTailSequence !== thread.tailSequence) return yield* storeError("worker capacity", "Canonical tail changed");
+		const index = yield* readyIndex(request.threadId, thread.tailSequence).pipe(Effect.mapError((e) => storeError("worker capacity", e.message)));
+		const worker = index.workers.get(request.workerThreadId);
+		return ThreadWorkerCapacity.make({
 			threadId: request.threadId,
-			reason: "digest-mismatch"
+			tailSequence: thread.tailSequence,
+			activeWorkers: Math.min(index.workers.size, request.activeLimit + 1),
+			workerActive: worker !== void 0,
+			pendingInputs: Math.min(request.update ? worker?.update ?? 0 : worker?.ordinary ?? 0, request.pendingLimit + 1)
 		});
-		return Option.some(checkpoint);
 	});
-	return ThreadStore.of({
+	const threadStore = ThreadStore.of({
+		work,
+		archives,
+		verification: { verify: (unvalidated) => withMutation(Effect.gen(function* () {
+			const request = yield* validate(ThreadVerificationRequest, "verify Thread", unvalidated);
+			const thread = yield* findThread(MutableRef.get(state.ref), request.threadId);
+			const id = request.threadId;
+			const reader = importReader(id, thread);
+			const submissions = () => ledgerTransfer?.submissions(id) ?? Stream.empty;
+			const runs = Stream.fromIterable(thread.runRecords.keys()).pipe(Stream.map((runId) => Schema.decodeSync(RunId)(runId)));
+			const checkpoint = yield* loadCheckpoint(LoadCheckpointRequest.make({ threadId: id })).pipe(Effect.mapError((cause) => Schema.is(CheckpointRejected)(cause) ? storeError("verify checkpoint", "Invalid checkpoint anchor", cause) : cause));
+			return yield* verifyThreadInvariants({
+				threadId: id,
+				runs,
+				executions: Stream.fromIterable(thread.executions.values()),
+				submissions: submissions(),
+				pages: streamExport({ threadId: id }).pipe(Stream.provideService(ThreadExportSource, { export: verificationPage }), Stream.mapError((cause) => Schema.is(ThreadExportRejected)(cause) ? storeError("verify Thread", "Internal verification snapshot changed") : cause)),
+				...Option.isNone(checkpoint) ? {} : { checkpoint: checkpoint.value },
+				checkpointsSupported: true,
+				...request.requireAllSettled === void 0 ? {} : { requireAllSettled: request.requireAllSettled }
+			}).pipe(Effect.provide(ThreadImportReader.layer(reader)), Effect.provideService(Crypto.Crypto, crypto));
+		})) },
+		readWorkerCapacity,
 		readIdentity,
 		countPeerMessages,
-		materialize,
+		materialize: (request) => withMutation(materialize(request)),
 		append,
+		readExecution: (request) => withMutation(Effect.gen(function* () {
+			const thread = (yield* Ref.get(state)).threads.get(request.threadId);
+			if (thread === void 0) return yield* ThreadNotMaterialized.make({ threadId: request.threadId });
+			return Option.fromUndefinedOr(thread.executions.get(request.runId));
+		})),
 		read,
+		readPrompt,
 		observe,
-		export: exportThread,
+		export: (request) => checkExportSource(request.threadId).pipe(Effect.andThen(withMutation(exportThread(request)))),
 		inspectTail,
 		checkpoints: {
-			save: saveCheckpoint,
+			save: (request) => withMutation(saveCheckpoint(request)),
 			load: loadCheckpoint
-		},
-		recoveryCheckpoints: {
-			save: saveRecoveryCheckpoint,
-			load: loadRecoveryCheckpoint
 		}
 	});
+	return Context.make(ThreadStore, threadStore).pipe(Context.add(StorageOwner, owner), Context.add(ThreadImport, { import: importThread }), Context.add(MemoryThreadStoreKernel, {
+		owner,
+		withMutation,
+		retainDelivery,
+		checkThreadCapacity: (threadId) => Effect.suspend(() => !MutableRef.get(workState.ref).has(threadId) && MutableRef.get(workState.ref).size >= maxThreads ? Effect.fail(storeError("Thread capacity", "Retained Thread quota exceeded")) : Effect.void),
+		initializeWork: (threadId) => {
+			if (!MutableRef.get(state.ref).threads.has(threadId) && !MutableRef.get(workState.ref).has(threadId)) publishWork(threadId, emptyWorkIndex());
+		},
+		registerWorkOwner: (kind, owner) => withMutation(Effect.sync(() => {
+			if (workOwners.has(kind)) throw new Error(`MemoryThreadStore already has a ${kind} work owner`);
+			workOwners.set(kind, owner);
+		})),
+		registerDeliveryLookup: (lookup) => withMutation(Effect.sync(() => {
+			if (deliveryLookup !== void 0) throw new Error("MemoryThreadStore already has a delivery lookup");
+			deliveryLookup = lookup;
+		})),
+		registerLedgerTransfer: (transfer) => withMutation(Effect.sync(() => {
+			if (ledgerTransfer !== void 0) throw new Error("MemoryThreadStore already has a paired SubmissionLedger");
+			ledgerTransfer = transfer;
+		})),
+		registerDeliveryTransfer: (transfer) => withMutation(Effect.sync(() => {
+			if (deliveryTransfer !== void 0) throw new Error("MemoryThreadStore already has a paired delivery store");
+			deliveryTransfer = transfer;
+		})),
+		prepareAppend,
+		appendPrepared,
+		record: (threadId, recordId) => Ref.get(state).pipe(Effect.map((current) => current.threads.get(threadId)?.byId.get(recordId)?.record)),
+		toolCallResults: (threadId, runId, toolCallId) => Ref.get(state).pipe(Effect.map((current) => (current.threads.get(threadId)?.operationRecords.get(JSON.stringify([
+			runId,
+			toolCallId,
+			"settled"
+		])) ?? []).slice(0, 2).map((entry) => entry.record))),
+		tail: (threadId) => inspectTail(ThreadTailRequest.make({ threadId }))
+	}));
 });
 /**
 * In-memory canonical Thread persistence. Durable accepted work is served by the separate
-* SubmissionLedger port; this Layer deliberately provides only the ThreadStore.
+* SubmissionLedger port; this Layer provides ThreadStore, ThreadReader, and ThreadImport.
+* Importing admissions requires a MemorySubmissionLedger paired with this store.
 */
-const MemoryThreadStoreLive = Layer.effect(ThreadStore, makeThreadStore);
+const MemoryThreadStoreLive = ThreadReader.layer().pipe(Layer.provideMerge(Layer.effectContext(makeThreadStore)));
 /** Configure a finite retained Thread capacity. Invalid construction options throw immediately. */
 const memoryThreadStoreLayer = (options = {}) => MemoryThreadStoreLive.pipe(Layer.provide(Layer.succeed(ThreadCapacity)(Schema.decodeSync(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(65536)))(options.maxThreads ?? MAX_THREADS))));
 //#endregion