@effect-agent/storage-cloudflare 0.1.0-beta.38 → 0.1.0-beta.40

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResolution, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, ConversationCheckpoint, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleUsesCapacity, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/session";
+import { t as DoStorageFailpoint } from "./do-storage-failpoint-C-Qtchs7.mjs";
+import { AbortCommand, AbortIntent, AcceptedEvent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResolution, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecision, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeliveryChange, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, PersistedJson, ProducerEpoch, QueueSequence, RecordEnvelope, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementOutcome, SettlementReservation, SettlementReservationSnapshot, SourcePartition, SubmissionLedger, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, SuspendRequest, SuspensionReason, SuspensionSnapshot, ThreadCheckpoint, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, applySubscriptionDeliveryChange, defaultSchedulingLimits, digestCanonicalBatch, sameAcceptedEventIdentity, sameSourcePartition, scheduleDeadline, scheduleUsesCapacity, settlementFailureFromRecord, submissionAbortRecordId, subscriptionCanSelect, subscriptionDeliveryCanSelect, subscriptionDeliveryKeyString } from "@effect-agent/thread";
 import { Clock, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Predicate, Ref, Result, Schema, Stream } from "effect";
 import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-do";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
@@ -64,7 +65,7 @@ var DoAppendConflict = class extends Schema.TaggedError()("DoAppendConflict", {
 	actualTailDigest: Schema.optionalKey(Schema.String)
 }) {};
 /**
-* A producer epoch does not match the Conversation's current writer registration. Appends
+* A producer epoch does not match the Thread's current writer registration. Appends
 * require the exact registered epoch, so both older and newer unregistered epochs are fenced;
 * a newer epoch takes over by materializing first.
 */
@@ -91,7 +92,7 @@ const DoStorageFailpointLocation = Schema.Literals([
 	"append:after-record-insert",
 	"append:after-tail-update",
 	"append:after",
-	"export:after-conversation-read",
+	"export:after-thread-read",
 	"save-checkpoint:before",
 	"save-checkpoint:after",
 	"ledger:admit:before",
@@ -145,32 +146,25 @@ var DoStorageFailpointError = class extends Schema.TaggedError()("DoStorageFailp
 };
 //#endregion
 //#region src/migrations.ts
+/** The current storage version recorded in `effect_agent_meta`. */
+const CurrentDoStorageVersion = 2;
 /**
-* The exact-or-fresh storage version recorded in `effect_agent_meta`. Cloudflare is a fresh
-* platform, so there is exactly ONE migration carrying the complete current schema — no
-* v1→v4 history to replay (deployment spec §9: no rolling data-version promise during
-* private development).
-*/
-const CurrentDoStorageVersion = 1;
-/**
-* The Conversation Durable Object schema. Table names and columns mirror the Node/SQLite v4
-* schema byte-for-byte (`packages/storage-sqlite/src/migrations.ts`, migrations 1–4 collapsed
-* into their final shape) so the shared conformance suites and crash-matrix rows address
-* identical durable state. Two DC-specific additions:
+* The Thread Durable Object schema shares its thread and ledger tables with Node/SQLite.
+* Schedules and subscriptions use separate Durable Objects. Two DC-specific additions:
 *
 * 1. `effect_agent_meta` replaces `PRAGMA user_version` as the exact-or-fresh version gate —
 *    a meta table is portable regardless of which PRAGMAs Durable Object SQL storage allows.
 * 2. `effect_agent_child_settlements` is the durable cross-store notification marker the
 *    SubmissionLedger port contract mandates for cross-store adapters (`suspend`'s covering
-*    check and `recordChildSettled`'s wake both consult it): parent and child Conversations
+*    check and `recordChildSettled`'s wake both consult it): parent and child Threads
 *    live in different Durable Objects, so a child settlement reported before the parent's
 *    suspend commits must be observable from the PARENT's own storage.
 */
-const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversation_object": Effect.gen(function* () {
+const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_thread_object": Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
 	yield* sql`
-      CREATE TABLE effect_agent_conversations (
-        conversation_id TEXT PRIMARY KEY NOT NULL,
+      CREATE TABLE effect_agent_threads (
+        thread_id TEXT PRIMARY KEY NOT NULL,
         created_at TEXT NOT NULL,
         tail_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
@@ -179,53 +173,53 @@ const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversat
     `.withoutTransform;
 	yield* sql`
       CREATE TABLE effect_agent_canonical_batches (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         first_sequence INTEGER NOT NULL,
         last_sequence INTEGER NOT NULL,
         batch_digest TEXT NOT NULL,
         tail_digest TEXT NOT NULL,
         batch_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, batch_id),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, batch_id),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 	yield* sql`
       CREATE TABLE effect_agent_canonical_records (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         sequence INTEGER NOT NULL,
         record_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         record_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, sequence),
-        UNIQUE (conversation_id, record_id),
-        FOREIGN KEY (conversation_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(conversation_id, batch_id)
+        PRIMARY KEY (thread_id, sequence),
+        UNIQUE (thread_id, record_id),
+        FOREIGN KEY (thread_id, batch_id)
+          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 	yield* sql`
       CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (conversation_id, batch_id, sequence)
+        ON effect_agent_canonical_records (thread_id, batch_id, sequence)
     `.withoutTransform;
 	yield* sql`
       CREATE TABLE effect_agent_checkpoints (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         through_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
         checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, through_sequence),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, through_sequence),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 	yield* sql`
       CREATE TABLE effect_agent_submissions (
         submission_id TEXT PRIMARY KEY NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         queue_sequence INTEGER NOT NULL,
         principal TEXT NOT NULL,
         idempotency_key TEXT NOT NULL,
@@ -248,8 +242,8 @@ const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversat
         unknown_tool_call_ids_json TEXT,
         parent_submission_id TEXT,
         parent_tool_call_id TEXT,
-        UNIQUE (conversation_id, principal, idempotency_key),
-        UNIQUE (conversation_id, queue_sequence)
+        UNIQUE (thread_id, principal, idempotency_key),
+        UNIQUE (thread_id, queue_sequence)
       )
     `.withoutTransform;
 	yield* sql`
@@ -277,7 +271,7 @@ const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversat
       CREATE TABLE effect_agent_attempts (
         attempt_id TEXT PRIMARY KEY NOT NULL,
         submission_id TEXT NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         owner_producer_id TEXT NOT NULL,
         producer_epoch INTEGER NOT NULL,
         claimed_at TEXT NOT NULL,
@@ -377,7 +371,7 @@ const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversat
     `.withoutTransform;
 	yield* sql`
       INSERT INTO effect_agent_meta (key, value)
-      VALUES ('storage_version', ${String(1)})
+      VALUES ('storage_version', ${String(2)})
     `.withoutTransform;
 }) });
 //#endregion
@@ -390,10 +384,8 @@ const doMigrations = SqliteMigrator.fromRecord({ "1_current_cloudflare_conversat
 */
 const BoundedStoredText$1 = Schema.String.check(Schema.isMaxLength(2e6));
 const BoundedIdentifier$1 = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-const MAX_RECORDS_PER_CONVERSATION = 65536;
+const MAX_RECORDS_PER_THREAD = 65536;
 const MAX_IDENTIFIER_LENGTH$1 = 1024;
-/** Durable Object SQL storage allows at most 100 bound parameters per statement. */
-const MAX_BOUND_PARAMETERS = 100;
 const isSqlError = Schema.is(SqlError);
 const storedTextBytes = (value) => new TextEncoder().encode(value).byteLength;
 const chunked = (values, size) => {
@@ -403,8 +395,8 @@ const chunked = (values, size) => {
 };
 var DoMetaRow = class extends Schema.Class("DoMetaRow")({ value: Schema.NonEmptyString.check(Schema.isMaxLength(128)) }) {};
 var DoNameRow = class extends Schema.Class("DoNameRow")({ name: BoundedIdentifier$1 }) {};
-var ConversationRow = class extends Schema.Class("ConversationRow")({
-	conversation_id: BoundedIdentifier$1,
+var ThreadRow = class extends Schema.Class("ThreadRow")({
+	thread_id: BoundedIdentifier$1,
 	created_at: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
 	producer_epoch: ProducerEpoch,
 	tail_digest: BoundedStoredText$1,
@@ -414,21 +406,21 @@ var BatchRow = class extends Schema.Class("BatchRow")({
 	batch_digest: BoundedStoredText$1,
 	batch_id: BoundedIdentifier$1,
 	batch_json: BoundedStoredText$1,
-	conversation_id: BoundedIdentifier$1,
+	thread_id: BoundedIdentifier$1,
 	first_sequence: CanonicalSequence,
 	last_sequence: CanonicalSequence,
 	tail_digest: BoundedStoredText$1
 }) {};
 var RecordRow = class extends Schema.Class("RecordRow")({
 	batch_id: BoundedIdentifier$1,
-	conversation_id: BoundedIdentifier$1,
+	thread_id: BoundedIdentifier$1,
 	record_id: BoundedIdentifier$1,
 	record_json: BoundedStoredText$1,
 	sequence: CanonicalSequence
 }) {};
 var CheckpointRow = class extends Schema.Class("CheckpointRow")({
 	checkpoint_json: BoundedStoredText$1,
-	conversation_id: BoundedIdentifier$1,
+	thread_id: BoundedIdentifier$1,
 	tail_digest: BoundedStoredText$1,
 	through_sequence: CanonicalSequence
 }) {};
@@ -440,7 +432,7 @@ var RawAppendRequest = class extends Schema.Class("@effect-agent/storage-cloudfl
 	batchDigest: BoundedStoredText$1,
 	batchId: BoundedIdentifier$1,
 	batchJson: BoundedStoredText$1,
-	conversationId: BoundedIdentifier$1,
+	threadId: BoundedIdentifier$1,
 	expectedTailDigest: BoundedStoredText$1,
 	expectedTailSequence: CanonicalSequence,
 	producerEpoch: ProducerEpoch,
@@ -454,36 +446,36 @@ var RawAppendResult = class extends Schema.Class("@effect-agent/storage-cloudfla
 	tailDigest: BoundedStoredText$1
 }) {};
 var RawReadRequest = class extends Schema.Class("@effect-agent/storage-cloudflare/RawReadRequest")({
-	conversationId: BoundedIdentifier$1,
+	threadId: BoundedIdentifier$1,
 	fromSequenceExclusive: CanonicalSequence,
 	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
 }) {};
 var RawCheckpoint = class extends Schema.Class("@effect-agent/storage-cloudflare/RawCheckpoint")({
 	checkpointJson: BoundedStoredText$1,
-	conversationId: BoundedIdentifier$1,
+	threadId: BoundedIdentifier$1,
 	tailDigest: BoundedStoredText$1,
 	throughSequence: CanonicalSequence
 }) {};
-var RawConversationExport = class extends Schema.Class("@effect-agent/storage-cloudflare/RawConversationExport")({
+var RawThreadExport = class extends Schema.Class("@effect-agent/storage-cloudflare/RawThreadExport")({
 	batches: Schema.Array(BatchRow),
 	checkpoints: Schema.Array(CheckpointRow),
-	conversation: ConversationRow,
+	thread: ThreadRow,
 	records: Schema.Array(RecordRow)
 }) {};
-const noFailpoint$1 = () => Effect.void;
+const noFailpoint = () => Effect.void;
 const storageError = (operation) => (error) => DoStorageError.make({
 	cause: error,
 	operation,
 	message: error.message
 });
 /** Decode raw Durable Object SQLite rows against a Schema, reporting failures as typed corruption. */
-const decodeRows$1 = Effect.fn((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
+const decodeRows$2 = Effect.fn((schema, table, rowKey, rows) => Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError((error) => DoStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: String(error)
 }))));
 /** Decode exactly one raw row against a Schema, reporting failures as typed corruption. */
-const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows$1(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
+const decodeSingleRow = Effect.fn((schema, table, rowKey, rows) => decodeRows$2(schema, table, rowKey, rows).pipe(Effect.flatMap((decoded) => decoded.length === 1 ? Effect.succeed(decoded[0]) : Effect.fail(DoStorageCorruptionError.make({
 	table,
 	rowKey,
 	message: `Expected exactly one row but found ${decoded.length}.`
@@ -497,7 +489,7 @@ const REQUIRED_TABLES = [
 	"effect_agent_checkpoints",
 	"effect_agent_child_reservations",
 	"effect_agent_child_settlements",
-	"effect_agent_conversations",
+	"effect_agent_threads",
 	"effect_agent_meta",
 	"effect_agent_settlement_reservations",
 	"effect_agent_submission_ownership",
@@ -511,14 +503,14 @@ const REQUIRED_TABLES = [
 * through output gates) and no busy timeout (a Durable Object has exactly one writer): the
 * Node machinery those served has no DC analogue and is deliberately absent.
 */
-const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint$1, maxStoredValueBytes) {
+const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(function* (sql, failpoint = noFailpoint, maxStoredValueBytes) {
 	const metaTableRows = yield* sql`
     SELECT name
     FROM sqlite_master
     WHERE type = 'table'
       AND name = 'effect_agent_meta'
   `.pipe(Effect.mapError(storageError("read storage version table")));
-	if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
+	if ((yield* decodeRows$2(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_meta", metaTableRows)).length === 0) {
 		const existingRows = yield* sql`
       SELECT name
       FROM sqlite_master
@@ -526,9 +518,9 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
         AND name LIKE 'effect_agent_%'
       ORDER BY name
     `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
-		if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
+		if ((yield* decodeRows$2(Schema.Array(DoNameRow), "sqlite_master", "effect_agent_%", existingRows)).length > 0) return yield* DoStorageCompatibilityError.make({
 			actualVersion: 0,
-			supportedVersion: 1,
+			supportedVersion: 2,
 			message: "The Durable Object contains unversioned Effect Agent tables. Reset the development namespace explicitly; refusing to mutate ambiguous stored data."
 		});
 		yield* SqliteMigrator.run({ loader: doMigrations }).pipe(Effect.provideService(SqlClient.SqlClient, sql), Effect.mapError((error) => DoStorageError.make({
@@ -543,12 +535,12 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
       WHERE key = 'storage_version'
     `.pipe(Effect.mapError(storageError("read storage version")));
 		const version = yield* decodeSingleRow(Schema.Array(DoMetaRow), "effect_agent_meta", "storage_version", versionRows);
-		if (version.value !== String(1)) {
+		if (version.value !== String(2)) {
 			const actualVersion = Number.parseInt(version.value, 10);
 			return yield* DoStorageCompatibilityError.make({
 				actualVersion: Number.isSafeInteger(actualVersion) ? actualVersion : -1,
-				supportedVersion: 1,
-				message: `The Durable Object uses private-development storage version ${version.value}; this build supports exactly version 1. Replace the development namespace explicitly; automatic stored-data migrations are not provided during private development.`
+				supportedVersion: 2,
+				message: `The Durable Object uses private-development storage version ${version.value}; this build supports exactly version 2. Replace the development namespace explicitly; automatic stored-data migrations are not provided during private development.`
 			});
 		}
 	}
@@ -559,9 +551,9 @@ const ensureCurrentStorage = Effect.fn("DoJournal.ensureCurrentStorage")(functio
       AND name IN ${sql.in([...REQUIRED_TABLES])}
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
-	if ((yield* decodeRows$1(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
-		actualVersion: 1,
-		supportedVersion: 1,
+	if ((yield* decodeRows$2(Schema.Array(DoNameRow), "sqlite_master", "required_tables", requiredRows)).length !== REQUIRED_TABLES.length) return yield* DoStorageCompatibilityError.make({
+		actualVersion: 2,
+		supportedVersion: 2,
 		message: "The Durable Object claims the current format but is missing required tables. Reset the corrupt private-development data."
 	});
 	return makeJournal(sql, failpoint, maxStoredValueBytes);
@@ -589,45 +581,45 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 	* transaction.
 	*/
 	const withWriteTransaction = (operation) => (effect) => sql.withTransaction(effect).pipe(Effect.mapError((error) => isSqlError(error) ? storageError(operation)(error) : error), Effect.withSpan("DoJournal.withWriteTransaction", { attributes: { operation } }));
-	const materialize = Effect.fn("DoJournal.materialize")(function* (conversationId, createdAt, emptyTailDigest, producerEpoch) {
-		if (conversationId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
-			operation: "materialize conversation",
-			message: "Conversation identity exceeds the Durable Object storage bounds."
+	const materialize = Effect.fn("DoJournal.materialize")(function* (threadId, createdAt, emptyTailDigest, producerEpoch) {
+		if (threadId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
+			operation: "materialize thread",
+			message: "Thread identity exceeds the Durable Object storage bounds."
 		});
-		yield* checkValueBound("materialize conversation", emptyTailDigest);
+		yield* checkValueBound("materialize thread", emptyTailDigest);
 		yield* withWriteTransaction("materialize transaction")(Effect.gen(function* () {
 			const existingRows = yield* sql`
           SELECT
-            conversation_id,
+            thread_id,
             created_at,
             tail_sequence,
             tail_digest,
             producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${conversationId}
-        `.pipe(Effect.mapError(storageError("read materialized conversation")));
-			const existing = yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, existingRows);
+          FROM effect_agent_threads
+          WHERE thread_id = ${threadId}
+        `.pipe(Effect.mapError(storageError("read materialized thread")));
+			const existing = yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, existingRows);
 			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
-				table: "effect_agent_conversations",
-				rowKey: conversationId,
-				message: "A conversation primary key returned more than one row."
+				table: "effect_agent_threads",
+				rowKey: threadId,
+				message: "A thread primary key returned more than one row."
 			});
 			if (existing.length === 0) {
 				yield* sql`
-            INSERT INTO effect_agent_conversations (
-              conversation_id,
+            INSERT INTO effect_agent_threads (
+              thread_id,
               created_at,
               tail_sequence,
               tail_digest,
               producer_epoch
             ) VALUES (
-              ${conversationId},
+              ${threadId},
               ${createdAt},
               0,
               ${emptyTailDigest},
               ${producerEpoch}
             )
-          `.pipe(Effect.mapError(storageError("materialize conversation")));
+          `.pipe(Effect.mapError(storageError("materialize thread")));
 				return;
 			}
 			if (producerEpoch < existing[0].producer_epoch) return yield* DoFenceRejected.make({
@@ -636,27 +628,27 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 				message: `Producer epoch ${producerEpoch} is stale; current epoch is ${existing[0].producer_epoch}.`
 			});
 			if (producerEpoch > existing[0].producer_epoch) yield* sql`
-            UPDATE effect_agent_conversations
+            UPDATE effect_agent_threads
             SET producer_epoch = ${producerEpoch}
-            WHERE conversation_id = ${conversationId}
+            WHERE thread_id = ${threadId}
           `.pipe(Effect.mapError(storageError("advance materialization epoch")));
 		}));
 	});
-	const getConversation = Effect.fn("DoJournal.getConversation")(function* (conversationId) {
+	const getThread = Effect.fn("DoJournal.getThread")(function* (threadId) {
 		const rows = yield* sql`
       SELECT
-        conversation_id,
+        thread_id,
         created_at,
         tail_sequence,
         tail_digest,
         producer_epoch
-      FROM effect_agent_conversations
-      WHERE conversation_id = ${conversationId}
-    `.pipe(Effect.mapError(storageError("read conversation")));
-		return yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, rows);
+      FROM effect_agent_threads
+      WHERE thread_id = ${threadId}
+    `.pipe(Effect.mapError(storageError("read thread")));
+		return yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
 	});
 	const append = Effect.fn("DoJournal.append")(function* (request) {
-		if (request.conversationId.length > MAX_IDENTIFIER_LENGTH$1 || request.batchId.length > MAX_IDENTIFIER_LENGTH$1 || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH$1)) return yield* DoStorageError.make({
+		if (request.threadId.length > MAX_IDENTIFIER_LENGTH$1 || request.batchId.length > MAX_IDENTIFIER_LENGTH$1 || request.records.some((record) => record.recordId.length > MAX_IDENTIFIER_LENGTH$1)) return yield* DoStorageError.make({
 			operation: "append canonical batch",
 			message: "Canonical identifiers exceed the Durable Object storage bounds."
 		});
@@ -670,25 +662,25 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 				message: `Batch ${request.batchId} contains duplicate canonical record IDs.`,
 				reason: "record-identity"
 			});
-			const conversationRows = yield* sql`
+			const threadRows = yield* sql`
           SELECT
-            conversation_id,
+            thread_id,
             created_at,
             tail_sequence,
             tail_digest,
             producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${request.conversationId}
+          FROM effect_agent_threads
+          WHERE thread_id = ${request.threadId}
         `.pipe(Effect.mapError(storageError("read append tail")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", request.conversationId, conversationRows);
-			if (request.producerEpoch !== conversation.producer_epoch) return yield* DoFenceRejected.make({
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", request.threadId, threadRows);
+			if (request.producerEpoch !== thread.producer_epoch) return yield* DoFenceRejected.make({
 				producerEpoch: request.producerEpoch,
-				actualEpoch: conversation.producer_epoch,
-				message: `Producer epoch ${request.producerEpoch} is not the current epoch ${conversation.producer_epoch}.`
+				actualEpoch: thread.producer_epoch,
+				message: `Producer epoch ${request.producerEpoch} is not the current epoch ${thread.producer_epoch}.`
 			});
 			const batchRows = yield* sql`
           SELECT
-            conversation_id,
+            thread_id,
             batch_id,
             first_sequence,
             last_sequence,
@@ -696,13 +688,13 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
             tail_digest,
             batch_json
           FROM effect_agent_canonical_batches
-          WHERE conversation_id = ${request.conversationId}
+          WHERE thread_id = ${request.threadId}
             AND batch_id = ${request.batchId}
         `.pipe(Effect.mapError(storageError("read idempotent batch")));
-			const batches = yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.conversationId}/${request.batchId}`, batchRows);
+			const batches = yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${request.threadId}/${request.batchId}`, batchRows);
 			if (batches.length > 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_canonical_batches",
-				rowKey: `${request.conversationId}/${request.batchId}`,
+				rowKey: `${request.threadId}/${request.batchId}`,
 				message: "A canonical batch primary key returned more than one row."
 			});
 			if (batches.length === 1) {
@@ -718,37 +710,37 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 					tailDigest: existing.tail_digest
 				});
 			}
-			if (request.expectedTailSequence !== conversation.tail_sequence || request.expectedTailDigest !== conversation.tail_digest) return yield* DoAppendConflict.make({
-				message: `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} but found ${conversation.tail_sequence}/${conversation.tail_digest}.`,
+			if (request.expectedTailSequence !== thread.tail_sequence || request.expectedTailDigest !== thread.tail_digest) return yield* DoAppendConflict.make({
+				message: `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} but found ${thread.tail_sequence}/${thread.tail_digest}.`,
 				reason: "tail",
-				actualTailSequence: conversation.tail_sequence,
-				actualTailDigest: conversation.tail_digest
+				actualTailSequence: thread.tail_sequence,
+				actualTailDigest: thread.tail_digest
 			});
-			if (conversation.tail_sequence + request.records.length > MAX_RECORDS_PER_CONVERSATION) return yield* DoStorageError.make({
+			if (thread.tail_sequence + request.records.length > MAX_RECORDS_PER_THREAD) return yield* DoStorageError.make({
 				operation: "append canonical batch",
-				message: `Conversation record limit ${MAX_RECORDS_PER_CONVERSATION} would be exceeded.`
+				message: `Thread record limit ${MAX_RECORDS_PER_THREAD} would be exceeded.`
 			});
 			const existingRecords = [];
-			for (const chunk of chunked(recordIds, MAX_BOUND_PARAMETERS - 10)) {
+			for (const chunk of chunked(recordIds, 90)) {
 				const existingRecordRows = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               sequence,
               record_id,
               batch_id,
               record_json
             FROM effect_agent_canonical_records
-            WHERE conversation_id = ${request.conversationId}
+            WHERE thread_id = ${request.threadId}
               AND record_id IN ${sql.in([...chunk])}
             ORDER BY sequence
           `.pipe(Effect.mapError(storageError("check canonical record identities")));
-				existingRecords.push(...yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}/record_ids`, existingRecordRows));
+				existingRecords.push(...yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}/record_ids`, existingRecordRows));
 			}
 			if (existingRecords.length > 0) return yield* DoAppendConflict.make({
 				message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
 				reason: "record-identity"
 			});
-			const firstSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(conversation.tail_sequence + 1).pipe(Effect.mapError((error) => DoStorageError.make({
+			const firstSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(thread.tail_sequence + 1).pipe(Effect.mapError((error) => DoStorageError.make({
 				cause: error,
 				operation: "append canonical batch",
 				message: error.message
@@ -760,7 +752,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 			})));
 			yield* sql`
           INSERT INTO effect_agent_canonical_batches (
-            conversation_id,
+            thread_id,
             batch_id,
             first_sequence,
             last_sequence,
@@ -768,7 +760,7 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
             tail_digest,
             batch_json
           ) VALUES (
-            ${request.conversationId},
+            ${request.threadId},
             ${request.batchId},
             ${firstSequence},
             ${lastSequence},
@@ -781,13 +773,13 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 			yield* Effect.forEach(request.records, (record, index) => Effect.gen(function* () {
 				yield* sql`
                   INSERT INTO effect_agent_canonical_records (
-                    conversation_id,
+                    thread_id,
                     sequence,
                     record_id,
                     batch_id,
                     record_json
                   ) VALUES (
-                    ${request.conversationId},
+                    ${request.threadId},
                     ${firstSequence + index},
                     ${record.recordId},
                     ${request.batchId},
@@ -797,13 +789,13 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 				yield* failpoint("append:after-record-insert");
 			}), { discard: true });
 			yield* sql`
-          UPDATE effect_agent_conversations
+          UPDATE effect_agent_threads
           SET
             tail_sequence = ${lastSequence},
             tail_digest = ${request.tailDigest},
             producer_epoch = ${request.producerEpoch}
-          WHERE conversation_id = ${request.conversationId}
-        `.pipe(Effect.mapError(storageError("advance conversation tail")));
+          WHERE thread_id = ${request.threadId}
+        `.pipe(Effect.mapError(storageError("advance thread tail")));
 			yield* failpoint("append:after-tail-update");
 			return RawAppendResult.make({
 				firstSequence,
@@ -816,36 +808,36 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 	const read = Effect.fn("DoJournal.read")(function* (request) {
 		const rows = yield* sql`
       SELECT
-        conversation_id,
+        thread_id,
         sequence,
         record_id,
         batch_id,
         record_json
       FROM effect_agent_canonical_records
-      WHERE conversation_id = ${request.conversationId}
+      WHERE thread_id = ${request.threadId}
         AND sequence > ${request.fromSequenceExclusive}
       ORDER BY sequence
       LIMIT ${request.limit}
     `.pipe(Effect.mapError(storageError("read canonical records")));
-		return yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.conversationId}>${request.fromSequenceExclusive}`, rows);
+		return yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", `${request.threadId}>${request.fromSequenceExclusive}`, rows);
 	});
-	const exportConversation = Effect.fn("DoJournal.exportConversation")(function* (conversationId) {
+	const exportThread = Effect.fn("DoJournal.exportThread")(function* (threadId) {
 		return yield* sql.withTransaction(Effect.gen(function* () {
-			const conversationRows = yield* sql`
+			const threadRows = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               created_at,
               tail_sequence,
               tail_digest,
               producer_epoch
-            FROM effect_agent_conversations
-            WHERE conversation_id = ${conversationId}
-          `.pipe(Effect.mapError(storageError("export conversation")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", conversationId, conversationRows);
-			yield* failpoint("export:after-conversation-read");
+            FROM effect_agent_threads
+            WHERE thread_id = ${threadId}
+          `.pipe(Effect.mapError(storageError("export thread")));
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", threadId, threadRows);
+			yield* failpoint("export:after-thread-read");
 			const batchRows = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               batch_id,
               first_sequence,
               last_sequence,
@@ -853,71 +845,71 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
               tail_digest,
               batch_json
             FROM effect_agent_canonical_batches
-            WHERE conversation_id = ${conversationId}
+            WHERE thread_id = ${threadId}
             ORDER BY first_sequence
           `.pipe(Effect.mapError(storageError("export canonical batches")));
 			const recordRows = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               sequence,
               record_id,
               batch_id,
               record_json
             FROM effect_agent_canonical_records
-            WHERE conversation_id = ${conversationId}
+            WHERE thread_id = ${threadId}
             ORDER BY sequence
           `.pipe(Effect.mapError(storageError("export canonical records")));
 			const checkpointRows = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               through_sequence,
               tail_digest,
               checkpoint_json
             FROM effect_agent_checkpoints
-            WHERE conversation_id = ${conversationId}
+            WHERE thread_id = ${threadId}
             ORDER BY through_sequence
           `.pipe(Effect.mapError(storageError("export checkpoints")));
-			return RawConversationExport.make({
-				conversation,
-				batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", conversationId, batchRows),
-				records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", conversationId, recordRows),
-				checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", conversationId, checkpointRows)
+			return RawThreadExport.make({
+				thread,
+				batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", threadId, batchRows),
+				records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", threadId, recordRows),
+				checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", threadId, checkpointRows)
 			});
 		})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("export transaction")(error))));
 	});
 	const saveCheckpoint = Effect.fn("DoJournal.saveCheckpoint")(function* (checkpoint) {
-		if (checkpoint.conversationId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
+		if (checkpoint.threadId.length > MAX_IDENTIFIER_LENGTH$1) return yield* DoStorageError.make({
 			operation: "save checkpoint",
 			message: "Checkpoint identity exceeds the Durable Object storage bounds."
 		});
 		yield* checkValueBound("save checkpoint", checkpoint.checkpointJson);
 		yield* withWriteTransaction("checkpoint transaction")(Effect.gen(function* () {
-			const conversationRows = yield* sql`
+			const threadRows = yield* sql`
           SELECT
-            conversation_id,
+            thread_id,
             created_at,
             tail_sequence,
             tail_digest,
             producer_epoch
-          FROM effect_agent_conversations
-          WHERE conversation_id = ${checkpoint.conversationId}
+          FROM effect_agent_threads
+          WHERE thread_id = ${checkpoint.threadId}
         `.pipe(Effect.mapError(storageError("read checkpoint tail")));
-			const conversation = yield* decodeSingleRow(Schema.Array(ConversationRow), "effect_agent_conversations", checkpoint.conversationId, conversationRows);
-			if (checkpoint.throughSequence > conversation.tail_sequence) return yield* DoCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${conversation.tail_sequence}.` });
+			const thread = yield* decodeSingleRow(Schema.Array(ThreadRow), "effect_agent_threads", checkpoint.threadId, threadRows);
+			if (checkpoint.throughSequence > thread.tail_sequence) return yield* DoCheckpointConflict.make({ message: `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ${thread.tail_sequence}.` });
 			const checkpointRows = yield* sql`
           SELECT
-            conversation_id,
+            thread_id,
             through_sequence,
             tail_digest,
             checkpoint_json
           FROM effect_agent_checkpoints
-          WHERE conversation_id = ${checkpoint.conversationId}
+          WHERE thread_id = ${checkpoint.threadId}
             AND through_sequence = ${checkpoint.throughSequence}
         `.pipe(Effect.mapError(storageError("read idempotent checkpoint")));
-			const existing = yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.conversationId}/${checkpoint.throughSequence}`, checkpointRows);
+			const existing = yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${checkpoint.threadId}/${checkpoint.throughSequence}`, checkpointRows);
 			if (existing.length > 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_checkpoints",
-				rowKey: `${checkpoint.conversationId}/${checkpoint.throughSequence}`,
+				rowKey: `${checkpoint.threadId}/${checkpoint.throughSequence}`,
 				message: "A checkpoint primary key returned more than one row."
 			});
 			if (existing.length === 1) {
@@ -926,12 +918,12 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 			}
 			yield* sql`
           INSERT INTO effect_agent_checkpoints (
-            conversation_id,
+            thread_id,
             through_sequence,
             tail_digest,
             checkpoint_json
           ) VALUES (
-            ${checkpoint.conversationId},
+            ${checkpoint.threadId},
             ${checkpoint.throughSequence},
             ${checkpoint.tailDigest},
             ${checkpoint.checkpointJson}
@@ -939,34 +931,34 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
         `.pipe(Effect.mapError(storageError("insert checkpoint")));
 		}));
 	});
-	const loadCheckpoint = Effect.fn("DoJournal.loadCheckpoint")(function* (conversationId, atOrBeforeSequence) {
+	const loadCheckpoint = Effect.fn("DoJournal.loadCheckpoint")(function* (threadId, atOrBeforeSequence) {
 		const rows = yield* sql`
       SELECT
-        conversation_id,
+        thread_id,
         through_sequence,
         tail_digest,
         checkpoint_json
       FROM effect_agent_checkpoints
-      WHERE conversation_id = ${conversationId}
+      WHERE thread_id = ${threadId}
         AND through_sequence <= ${atOrBeforeSequence}
       ORDER BY through_sequence DESC
       LIMIT 1
     `.pipe(Effect.mapError(storageError("load checkpoint")));
-		return yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${conversationId}<=${atOrBeforeSequence}`, rows);
+		return yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", `${threadId}<=${atOrBeforeSequence}`, rows);
 	});
 	return {
 		append,
 		checkValueBound,
-		exportConversation,
-		getConversation,
-		getTailDigestAt: Effect.fn("DoJournal.getTailDigestAt")(function* (conversationId, sequence) {
+		exportThread,
+		getThread,
+		getTailDigestAt: Effect.fn("DoJournal.getTailDigestAt")(function* (threadId, sequence) {
 			if (sequence === 0) {
-				const conversations = yield* getConversation(conversationId);
-				return conversations.length === 0 ? [] : [conversations[0].tail_sequence === 0 ? conversations[0].tail_digest : void 0].filter((value) => value !== void 0);
+				const threads = yield* getThread(threadId);
+				return threads.length === 0 ? [] : [threads[0].tail_sequence === 0 ? threads[0].tail_digest : void 0].filter((value) => value !== void 0);
 			}
 			const rows = yield* sql`
       SELECT
-        conversation_id,
+        thread_id,
         batch_id,
         first_sequence,
         last_sequence,
@@ -974,10 +966,10 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
         tail_digest,
         batch_json
       FROM effect_agent_canonical_batches
-      WHERE conversation_id = ${conversationId}
+      WHERE thread_id = ${threadId}
         AND last_sequence = ${sequence}
     `.pipe(Effect.mapError(storageError("read canonical digest at sequence")));
-			return (yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${conversationId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
+			return (yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", `${threadId}/${sequence}`, rows)).map((batch) => batch.tail_digest);
 		}),
 		loadCheckpoint,
 		materialize,
@@ -985,19 +977,19 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
 		saveCheckpoint,
 		scanStoredPayloads: Effect.fn("DoJournal.scanStoredPayloads")(function* () {
 			return yield* sql.withTransaction(Effect.gen(function* () {
-				const conversations = yield* sql`
+				const threads = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               created_at,
               tail_sequence,
               tail_digest,
               producer_epoch
-            FROM effect_agent_conversations
-            ORDER BY conversation_id
-          `.pipe(Effect.mapError(storageError("scan conversations")));
+            FROM effect_agent_threads
+            ORDER BY thread_id
+          `.pipe(Effect.mapError(storageError("scan threads")));
 				const batches = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               batch_id,
               first_sequence,
               last_sequence,
@@ -1005,32 +997,32 @@ const makeJournal = (sql, failpoint, maxStoredValueBytes) => {
               tail_digest,
               batch_json
             FROM effect_agent_canonical_batches
-            ORDER BY conversation_id, first_sequence
+            ORDER BY thread_id, first_sequence
           `.pipe(Effect.mapError(storageError("scan canonical batches")));
 				const records = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               sequence,
               record_id,
               batch_id,
               record_json
             FROM effect_agent_canonical_records
-            ORDER BY conversation_id, sequence
+            ORDER BY thread_id, sequence
           `.pipe(Effect.mapError(storageError("scan canonical records")));
 				const checkpoints = yield* sql`
             SELECT
-              conversation_id,
+              thread_id,
               through_sequence,
               tail_digest,
               checkpoint_json
             FROM effect_agent_checkpoints
-            ORDER BY conversation_id, through_sequence
+            ORDER BY thread_id, through_sequence
           `.pipe(Effect.mapError(storageError("scan checkpoints")));
 				return {
-					conversations: yield* decodeRows$1(Schema.Array(ConversationRow), "effect_agent_conversations", "startup_scan", conversations),
-					batches: yield* decodeRows$1(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
-					records: yield* decodeRows$1(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
-					checkpoints: yield* decodeRows$1(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
+					threads: yield* decodeRows$2(Schema.Array(ThreadRow), "effect_agent_threads", "startup_scan", threads),
+					batches: yield* decodeRows$2(Schema.Array(BatchRow), "effect_agent_canonical_batches", "startup_scan", batches),
+					records: yield* decodeRows$2(Schema.Array(RecordRow), "effect_agent_canonical_records", "startup_scan", records),
+					checkpoints: yield* decodeRows$2(Schema.Array(CheckpointRow), "effect_agent_checkpoints", "startup_scan", checkpoints)
 				};
 			})).pipe(Effect.catchTag("SqlError", (error) => Effect.fail(storageError("startup scan transaction")(error))));
 		}),
@@ -1081,78 +1073,44 @@ var DoStorageConfigValue = class extends Schema.Class("@effect-agent/storage-clo
 /** Explicit Durable Object storage configuration authority. */
 var DoStorageConfig = class extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageConfig") {};
 //#endregion
-//#region src/do-storage-failpoint.ts
-const noFailpoint = () => Effect.void;
-/** Test-only control for replacing the active Durable Object failpoint handler. */
-var DoStorageFailpointTestControl = class extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpointTestControl") {};
-/** Explicit fault-injection authority used at Durable Object storage operation boundaries. */
-var DoStorageFailpoint = class DoStorageFailpoint extends Context.Service()("@effect-agent/storage-cloudflare/DoStorageFailpoint") {
-	/** Production default: no fault injection. */
-	static layer = Layer.succeed(this)({ hit: noFailpoint });
-	/** Reusable test Layer with a control service backed by the same handler Ref. */
-	static layerTest = Layer.effectContext(Effect.gen(function* () {
-		const handler = yield* Ref.make(noFailpoint);
-		return Context.make(DoStorageFailpoint, DoStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(DoStorageFailpointTestControl, DoStorageFailpointTestControl.of({
-			clear: Ref.set(handler, noFailpoint),
-			setHandler: (next) => Ref.set(handler, next)
-		})));
-	}));
-};
-/**
-* The DC-specific eviction failpoint mode: instead of failing typed, an armed hit evicts the
-* Durable Object through an injected `evict` thunk — in production-shaped harnesses that thunk
-* is `() => ctx.abort()`, the platform's real failure mode. `ctx.abort()` never returns (it
-* throws while destroying the in-memory instance and every in-flight implicit or explicit
-* storage transaction rolls back), so an armed hit ends the current Attempt exactly like an
-* unannounced platform eviction; DO storage — the only correctness-critical state — survives
-* for the next incarnation, which the persisted alarm wakes without any incoming request.
-*
-* The handles stay injected: this package never imports `cloudflare:workers`, so the harness
-* that owns a `DurableObjectState` supplies the thunk.
-*/
-const evictionFailpointHandler = (options) => (location) => options.isArmed(location).pipe(Effect.flatMap((armed) => armed ? Effect.sync(() => {
-	options.evict(location);
-	throw new Error(`Durable Object eviction did not interrupt execution at ${location}.`);
-}) : Effect.void));
-//#endregion
-//#region src/do-conversation-store.ts
-const OffsetText = Schema.String.check(Schema.isMaxLength(4 * 1024));
+//#region src/do-thread-store.ts
+const OffsetText = Schema.String.check(Schema.isMaxLength(4096));
 const DO_OFFSET_PREFIX = "effect-agent-do@1:";
 const ZERO_CANONICAL_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
 const isDigest = Schema.is(Digest);
 const isDoFenceRejected = Schema.is(DoFenceRejected);
 const isDoAppendConflict = Schema.is(DoAppendConflict);
 const isDoCheckpointConflict = Schema.is(DoCheckpointConflict);
-const storeError = (operation, error) => ConversationStoreError.make({
+const storeError = (operation, error) => ThreadStoreError.make({
 	cause: error,
 	operation,
 	message: error.message
 });
-const schemaStoreError = (operation, error) => ConversationStoreError.make({
+const schemaStoreError = (operation, error) => ThreadStoreError.make({
 	cause: error,
 	operation,
 	message: error.message
 });
-const makeOffset = Effect.fn(function* (conversationId, sequence) {
-	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${DO_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
+const makeOffset = Effect.fn(function* (threadId, sequence) {
+	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.flatMap((validatedSequence) => Schema.decodeUnknownEffect(ObservationOffset)(`${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`)), Effect.mapError((error) => schemaStoreError("encode observation offset", error)));
 });
-const parseOffset = Effect.fn(function* (conversationId, offset) {
+const parseOffset = Effect.fn(function* (threadId, offset) {
 	if (offset === void 0) return ZERO_CANONICAL_SEQUENCE;
 	const text = yield* Schema.decodeUnknownEffect(OffsetText)(offset).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
-	const conversationPrefix = `${DO_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:`;
-	if (!text.startsWith(conversationPrefix)) return yield* ConversationStoreError.make({
+	const threadPrefix = `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:`;
+	if (!text.startsWith(threadPrefix)) return yield* ThreadStoreError.make({
 		operation: "decode observation offset",
-		message: "The observation offset belongs to a different adapter, storage version, or Conversation."
+		message: "The observation offset belongs to a different adapter, storage version, or Thread."
 	});
-	const sequenceText = text.slice(conversationPrefix.length);
-	if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) return yield* ConversationStoreError.make({
+	const sequenceText = text.slice(threadPrefix.length);
+	if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) return yield* ThreadStoreError.make({
 		operation: "decode observation offset",
 		message: "The observation offset is malformed."
 	});
 	return yield* Schema.decodeUnknownEffect(CanonicalSequence)(Number(sequenceText)).pipe(Effect.mapError((error) => schemaStoreError("decode observation offset", error)));
 });
-const mapFence = (conversationId, error) => FenceRejected.make({
-	conversationId,
+const mapFence = (threadId, error) => FenceRejected.make({
+	threadId,
 	actualEpoch: error.actualEpoch,
 	attemptedEpoch: error.producerEpoch
 });
@@ -1163,18 +1121,18 @@ const encodeCanonicalBatch = Effect.fn(function* (batch) {
 	return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(Effect.mapError((error) => schemaStoreError("encode canonical batch", error)));
 });
 const encodeCheckpoint = Effect.fn(function* (checkpoint) {
-	return yield* Schema.encodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
+	return yield* Schema.encodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint).pipe(Effect.mapError((error) => schemaStoreError("encode checkpoint", error)));
 });
 const decodeEnvelope = Effect.fn(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json).pipe(Effect.mapError((error) => ConversationStoreError.make({
+	const record = yield* Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(row.record_json).pipe(Effect.mapError((error) => ThreadStoreError.make({
 		operation: "decode canonical record",
 		message: error.message
 	})));
-	const conversationId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.conversationId)(row.conversation_id).pipe(Effect.mapError((error) => schemaStoreError("decode conversation identity", error)));
-	const offset = yield* makeOffset(conversationId, row.sequence);
+	const threadId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.threadId)(row.thread_id).pipe(Effect.mapError((error) => schemaStoreError("decode thread identity", error)));
+	const offset = yield* makeOffset(threadId, row.sequence);
 	const batchId = yield* Schema.decodeUnknownEffect(CanonicalRecordEnvelope.fields.batchId)(row.batch_id).pipe(Effect.mapError((error) => schemaStoreError("decode batch identity", error)));
 	return CanonicalRecordEnvelope.make({
-		conversationId,
+		threadId,
 		batchId,
 		sequence: row.sequence,
 		offset,
@@ -1182,18 +1140,18 @@ const decodeEnvelope = Effect.fn(function* (row) {
 	});
 });
 const decodeCheckpoint = Effect.fn(function* (checkpointJson) {
-	return yield* Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
+	return yield* Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpointJson).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
 });
-const requireConversation = Effect.fn("DoConversationStore.requireConversation")(function* (journal, conversationId) {
-	const rows = yield* journal.getConversation(conversationId).pipe(Effect.mapError((error) => storeError("read conversation", error)));
-	if (rows.length === 0) return yield* ConversationNotMaterialized.make({ conversationId });
+const requireThread = Effect.fn("DoThreadStore.requireThread")(function* (journal, threadId) {
+	const rows = yield* journal.getThread(threadId).pipe(Effect.mapError((error) => storeError("read thread", error)));
+	if (rows.length === 0) return yield* ThreadNotMaterialized.make({ threadId });
 	return rows[0];
 });
-const tailDigestAt = Effect.fn("DoConversationStore.tailDigestAt")(function* (journal, conversationId, sequence) {
+const tailDigestAt = Effect.fn("DoThreadStore.tailDigestAt")(function* (journal, threadId, sequence) {
 	if (sequence === 0) return EMPTY_TAIL_DIGEST;
-	const digests = yield* journal.getTailDigestAt(conversationId, sequence).pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
+	const digests = yield* journal.getTailDigestAt(threadId, sequence).pipe(Effect.mapError((error) => storeError("read checkpoint digest", error)));
 	if (digests.length !== 1) return yield* CheckpointRejected.make({
-		conversationId,
+		threadId,
 		reason: "digest-mismatch"
 	});
 	return yield* Schema.decodeUnknownEffect(Digest)(digests[0]).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint digest", error)));
@@ -1212,14 +1170,14 @@ const groupByKey = (rows, key) => {
 * and re-digested against the canonical chain. Routine opens skip this scan: per-operation
 * Schema decoding plus the digest chain already fail clearly on corrupt rows.
 */
-const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloads")(function* (journal, crypto) {
+const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(function* (journal, crypto) {
 	const stored = yield* journal.scanStoredPayloads();
 	const batches = yield* Effect.forEach(stored.batches, (batch) => Schema.decodeEffect(Schema.fromJsonString(CanonicalBatch))(batch.batch_json).pipe(Effect.map((decoded) => ({
 		decoded,
 		row: batch
 	})), Effect.mapError((error) => DoStorageCorruptionError.make({
 		table: "effect_agent_canonical_batches",
-		rowKey: `${batch.conversation_id}/${batch.batch_id}`,
+		rowKey: `${batch.thread_id}/${batch.batch_id}`,
 		message: error.message
 	}))));
 	const records = yield* Effect.forEach(stored.records, (record) => Schema.decodeEffect(Schema.fromJsonString(CanonicalRecord))(record.record_json).pipe(Effect.map((decoded) => ({
@@ -1227,31 +1185,31 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
 		row: record
 	})), Effect.mapError((error) => DoStorageCorruptionError.make({
 		table: "effect_agent_canonical_records",
-		rowKey: `${record.conversation_id}/${record.sequence}`,
+		rowKey: `${record.thread_id}/${record.sequence}`,
 		message: error.message
 	}))));
-	const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) => Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint.checkpoint_json).pipe(Effect.map((decoded) => ({
+	const checkpoints = yield* Effect.forEach(stored.checkpoints, (checkpoint) => Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint.checkpoint_json).pipe(Effect.map((decoded) => ({
 		decoded,
 		row: checkpoint
 	})), Effect.mapError((error) => DoStorageCorruptionError.make({
 		table: "effect_agent_checkpoints",
-		rowKey: `${checkpoint.conversation_id}/${checkpoint.through_sequence}`,
+		rowKey: `${checkpoint.thread_id}/${checkpoint.through_sequence}`,
 		message: error.message
 	}))));
-	const batchesByConversation = groupByKey(batches, ({ row }) => row.conversation_id);
-	const recordsByConversation = groupByKey(records, ({ row }) => row.conversation_id);
-	const checkpointsByConversation = groupByKey(checkpoints, ({ row }) => row.conversation_id);
-	const materializedIds = new Set(stored.conversations.map((conversation) => conversation.conversation_id));
-	for (const conversation of stored.conversations) {
-		const conversationBatches = batchesByConversation.get(conversation.conversation_id) ?? [];
-		const conversationRecords = recordsByConversation.get(conversation.conversation_id) ?? [];
-		const conversationCheckpoints = checkpointsByConversation.get(conversation.conversation_id) ?? [];
-		const recordsByBatch = groupByKey(conversationRecords, ({ row }) => row.batch_id);
+	const batchesByThread = groupByKey(batches, ({ row }) => row.thread_id);
+	const recordsByThread = groupByKey(records, ({ row }) => row.thread_id);
+	const checkpointsByThread = groupByKey(checkpoints, ({ row }) => row.thread_id);
+	const materializedIds = new Set(stored.threads.map((thread) => thread.thread_id));
+	for (const thread of stored.threads) {
+		const threadBatches = batchesByThread.get(thread.thread_id) ?? [];
+		const threadRecords = recordsByThread.get(thread.thread_id) ?? [];
+		const threadCheckpoints = checkpointsByThread.get(thread.thread_id) ?? [];
+		const recordsByBatch = groupByKey(threadRecords, ({ row }) => row.batch_id);
 		let previousDigest = EMPTY_TAIL_DIGEST;
 		let expectedSequence = 1;
 		const tailDigests = /* @__PURE__ */ new Map([[0, EMPTY_TAIL_DIGEST]]);
-		for (const { decoded: canonicalBatch, row: batchRow } of conversationBatches) {
-			const key = `${batchRow.conversation_id}/${batchRow.batch_id}`;
+		for (const { decoded: canonicalBatch, row: batchRow } of threadBatches) {
+			const key = `${batchRow.thread_id}/${batchRow.batch_id}`;
 			if (canonicalBatch.batchId !== batchRow.batch_id || batchRow.first_sequence !== expectedSequence || batchRow.last_sequence !== batchRow.first_sequence + canonicalBatch.records.length - 1) return yield* DoStorageCorruptionError.make({
 				table: "effect_agent_canonical_batches",
 				rowKey: key,
@@ -1296,24 +1254,24 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
 			expectedSequence = batchRow.last_sequence + 1;
 			tailDigests.set(batchRow.last_sequence, digest);
 		}
-		if (conversationRecords.length !== conversation.tail_sequence || conversation.tail_sequence !== expectedSequence - 1 || conversation.tail_digest !== previousDigest) return yield* DoStorageCorruptionError.make({
-			table: "effect_agent_conversations",
-			rowKey: conversation.conversation_id,
-			message: "Conversation tail does not match its canonical batch chain."
+		if (threadRecords.length !== thread.tail_sequence || thread.tail_sequence !== expectedSequence - 1 || thread.tail_digest !== previousDigest) return yield* DoStorageCorruptionError.make({
+			table: "effect_agent_threads",
+			rowKey: thread.thread_id,
+			message: "Thread tail does not match its canonical batch chain."
 		});
-		for (const checkpoint of conversationCheckpoints) if (checkpoint.decoded.conversationId !== conversation.conversation_id || checkpoint.decoded.throughSequence !== checkpoint.row.through_sequence || checkpoint.decoded.tailDigest !== checkpoint.row.tail_digest || tailDigests.get(checkpoint.row.through_sequence) !== checkpoint.row.tail_digest) return yield* DoStorageCorruptionError.make({
+		for (const checkpoint of threadCheckpoints) if (checkpoint.decoded.threadId !== thread.thread_id || checkpoint.decoded.throughSequence !== checkpoint.row.through_sequence || checkpoint.decoded.tailDigest !== checkpoint.row.tail_digest || tailDigests.get(checkpoint.row.through_sequence) !== checkpoint.row.tail_digest) return yield* DoStorageCorruptionError.make({
 			table: "effect_agent_checkpoints",
-			rowKey: `${conversation.conversation_id}/${checkpoint.row.through_sequence}`,
+			rowKey: `${thread.thread_id}/${checkpoint.row.through_sequence}`,
 			message: "Checkpoint identity or digest is not bound to a canonical batch tail."
 		});
 	}
-	if (batches.some(({ row }) => !materializedIds.has(row.conversation_id)) || records.some(({ row }) => !materializedIds.has(row.conversation_id)) || checkpoints.some(({ row }) => !materializedIds.has(row.conversation_id))) return yield* DoStorageCorruptionError.make({
-		table: "effect_agent_conversations",
+	if (batches.some(({ row }) => !materializedIds.has(row.thread_id)) || records.some(({ row }) => !materializedIds.has(row.thread_id)) || checkpoints.some(({ row }) => !materializedIds.has(row.thread_id))) return yield* DoStorageCorruptionError.make({
+		table: "effect_agent_threads",
 		rowKey: "startup_scan",
-		message: "Canonical rows exist without a materialized Conversation."
+		message: "Canonical rows exist without a materialized Thread."
 	});
 });
-const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* () {
+const makeServices$2 = Effect.fn("DoThreadStore.makeServices")(function* () {
 	const config = yield* DoStorageConfig;
 	const failpoint = yield* DoStorageFailpoint;
 	const sql = yield* SqlClient.SqlClient;
@@ -1322,16 +1280,16 @@ const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* (
 	if (config.verifyOnOpen) yield* decodeStartupPayloads(journal, crypto);
 	const provideCrypto = (effect) => Effect.provideService(effect, Crypto.Crypto, crypto);
 	const hitFailpoint = Effect.fn((location) => failpoint.hit(location).pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))));
-	const materialize = Effect.fn("DoConversationStore.materialize")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationMaterialization))(request).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
+	const materialize = Effect.fn("DoThreadStore.materialize")(function* (request) {
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(request).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
 		const now = yield* Clock.currentTimeMillis;
 		yield* hitFailpoint("materialize:before");
-		yield* journal.materialize(validated.conversationId, new Date(now).toISOString(), EMPTY_TAIL_DIGEST, validated.producerEpoch).pipe(Effect.mapError((error) => error._tag === "DoFenceRejected" ? mapFence(validated.conversationId, error) : storeError("materialize conversation", error)));
+		yield* journal.materialize(validated.threadId, new Date(now).toISOString(), EMPTY_TAIL_DIGEST, validated.producerEpoch).pipe(Effect.mapError((error) => error._tag === "DoFenceRejected" ? mapFence(validated.threadId, error) : storeError("materialize thread", error)));
 		yield* hitFailpoint("materialize:after");
 	});
-	const append = Effect.fn("DoConversationStore.append")(function* (request) {
+	const append = Effect.fn("DoThreadStore.append")(function* (request) {
 		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
-		yield* requireConversation(journal, validated.conversationId);
+		yield* requireThread(journal, validated.threadId);
 		const tailDigest = yield* provideCrypto(digestCanonicalBatch(validated.expectedTailDigest, validated.batch)).pipe(Effect.mapError((error) => storeError("digest canonical append", error)));
 		const batchJson = yield* encodeCanonicalBatch(validated.batch);
 		const rawRecords = yield* Effect.forEach(validated.batch.records, (record) => encodeCanonicalRecord(record).pipe(Effect.map((recordJson) => ({
@@ -1339,7 +1297,7 @@ const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* (
 			recordJson
 		}))));
 		const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
-			conversationId: validated.conversationId,
+			threadId: validated.threadId,
 			batchId: validated.batch.batchId,
 			batchDigest: tailDigest,
 			batchJson,
@@ -1351,15 +1309,15 @@ const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* (
 		}).pipe(Effect.mapError((error) => schemaStoreError("encode canonical append", error)));
 		yield* hitFailpoint("append:before");
 		const result = yield* journal.append(rawRequest).pipe(Effect.mapError((error) => {
-			if (isDoFenceRejected(error)) return mapFence(validated.conversationId, error);
+			if (isDoFenceRejected(error)) return mapFence(validated.threadId, error);
 			if (isDoAppendConflict(error)) return error.actualTailSequence !== void 0 && isDigest(error.actualTailDigest) ? AppendConflict.make({
-				conversationId: validated.conversationId,
+				threadId: validated.threadId,
 				batchId: validated.batch.batchId,
 				reason: error.reason,
 				actualTailSequence: error.actualTailSequence,
 				actualTailDigest: error.actualTailDigest
 			}) : AppendConflict.make({
-				conversationId: validated.conversationId,
+				threadId: validated.threadId,
 				batchId: validated.batch.batchId,
 				reason: error.reason
 			});
@@ -1368,30 +1326,30 @@ const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* (
 		yield* hitFailpoint("append:after");
 		return result;
 	});
-	const loadRecords = Effect.fn("DoConversationStore.loadRecords")(function* (request) {
+	const loadRecords = Effect.fn("DoThreadStore.loadRecords")(function* (request) {
 		const rows = yield* journal.read(request).pipe(Effect.mapError((error) => storeError("read canonical records", error)));
 		return yield* Effect.forEach(rows, decodeEnvelope);
 	});
-	const readEffect = Effect.fn("DoConversationStore.read")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationRead))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation read", error)));
-		yield* requireConversation(journal, validated.conversationId);
+	const readEffect = Effect.fn("DoThreadStore.read")(function* (request) {
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadRead))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread read", error)));
+		yield* requireThread(journal, validated.threadId);
 		const records = yield* loadRecords(RawReadRequest.make({
-			conversationId: validated.conversationId,
+			threadId: validated.threadId,
 			fromSequenceExclusive: validated.afterSequence ?? ZERO_CANONICAL_SEQUENCE,
 			limit: validated.limit
 		}));
 		return Stream.fromIterable(records);
 	});
 	const read = (request) => Stream.unwrap(readEffect(request));
-	const observeEffect = Effect.fn("DoConversationStore.observe")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationObservation))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation observation", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const initialSequence = yield* parseOffset(validated.conversationId, validated.afterOffset);
+	const observeEffect = Effect.fn("DoThreadStore.observe")(function* (request) {
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread observation", error)));
+		yield* requireThread(journal, validated.threadId);
+		const initialSequence = yield* parseOffset(validated.threadId, validated.afterOffset);
 		const cursor = yield* Ref.make(initialSequence);
-		const poll = Effect.fn("DoConversationStore.observePoll")(function* () {
+		const poll = Effect.fn("DoThreadStore.observePoll")(function* () {
 			const fromSequenceExclusive = yield* Ref.get(cursor);
 			const records = yield* loadRecords(RawReadRequest.make({
-				conversationId: validated.conversationId,
+				threadId: validated.threadId,
 				fromSequenceExclusive,
 				limit: 1024
 			}));
@@ -1405,96 +1363,98 @@ const makeServices$2 = Effect.fn("DoConversationStore.makeServices")(function* (
 		return Stream.fromIterableEffectRepeat(poll());
 	});
 	const observe = (request) => Stream.unwrap(observeEffect(request));
-	const exportConversation = Effect.fn("DoConversationStore.export")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationExportRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate conversation export", error)));
-		yield* requireConversation(journal, validated.conversationId);
-		const exported = yield* journal.exportConversation(validated.conversationId).pipe(Effect.mapError((error) => storeError("export conversation", error)));
+	const exportThread = Effect.fn("DoThreadStore.export")(function* (request) {
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadExportRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate thread export", error)));
+		yield* requireThread(journal, validated.threadId);
+		const exported = yield* journal.exportThread(validated.threadId).pipe(Effect.mapError((error) => storeError("export thread", error)));
 		const records = yield* Effect.forEach(exported.records, decodeEnvelope);
-		if (records.length > 65536) return yield* ConversationStoreError.make({
-			operation: "decode conversation export",
-			message: "The conversation exceeds the current export record limit."
+		if (records.length > 65536) return yield* ThreadStoreError.make({
+			operation: "decode thread export",
+			message: "The thread exceeds the current export record limit."
 		});
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(exported.conversation.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
-		return ConversationExport.make({
-			format: "effect-agent/conversation@1",
-			conversationId: validated.conversationId,
-			tailSequence: exported.conversation.tail_sequence,
+		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(exported.thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode export tail digest", error)));
+		return ThreadExport.make({
+			format: "effect-agent/thread@1",
+			threadId: validated.threadId,
+			tailSequence: exported.thread.tail_sequence,
 			tailDigest,
 			records
 		});
 	});
-	const inspectTail = Effect.fn("DoConversationStore.inspectTail")(function* (request) {
-		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationTailRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
-		const conversation = yield* requireConversation(journal, validated.conversationId);
-		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(conversation.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode tail digest", error)));
-		return ConversationTail.make({
-			conversationId: validated.conversationId,
-			tailSequence: conversation.tail_sequence,
+	const inspectTail = Effect.fn("DoThreadStore.inspectTail")(function* (request) {
+		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadTailRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate tail inspection", error)));
+		const thread = yield* requireThread(journal, validated.threadId);
+		const tailDigest = yield* Schema.decodeUnknownEffect(Digest)(thread.tail_digest).pipe(Effect.mapError((error) => schemaStoreError("decode tail digest", error)));
+		return ThreadTail.make({
+			threadId: validated.threadId,
+			tailSequence: thread.tail_sequence,
 			tailDigest,
-			producerEpoch: conversation.producer_epoch
+			producerEpoch: thread.producer_epoch
 		});
 	});
-	const saveCheckpoint = Effect.fn("DoConversationStore.saveCheckpoint")(function* (request) {
+	const saveCheckpoint = Effect.fn("DoThreadStore.saveCheckpoint")(function* (request) {
 		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
-		const conversation = yield* requireConversation(journal, validated.checkpoint.conversationId);
-		if (validated.checkpoint.throughSequence > conversation.tail_sequence) return yield* CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
+		const thread = yield* requireThread(journal, validated.checkpoint.threadId);
+		if (validated.checkpoint.throughSequence > thread.tail_sequence) return yield* CheckpointRejected.make({
+			threadId: validated.checkpoint.threadId,
 			reason: "ahead-of-tail"
 		});
-		if ((yield* tailDigestAt(journal, validated.checkpoint.conversationId, validated.checkpoint.throughSequence)) !== validated.checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
+		if ((yield* tailDigestAt(journal, validated.checkpoint.threadId, validated.checkpoint.throughSequence)) !== validated.checkpoint.tailDigest) return yield* CheckpointRejected.make({
+			threadId: validated.checkpoint.threadId,
 			reason: "digest-mismatch"
 		});
 		const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
 		const raw = RawCheckpoint.make({
-			conversationId: validated.checkpoint.conversationId,
+			threadId: validated.checkpoint.threadId,
 			throughSequence: validated.checkpoint.throughSequence,
 			tailDigest: validated.checkpoint.tailDigest,
 			checkpointJson
 		});
 		yield* hitFailpoint("save-checkpoint:before");
 		yield* journal.saveCheckpoint(raw).pipe(Effect.mapError((error) => isDoCheckpointConflict(error) ? CheckpointRejected.make({
-			conversationId: validated.checkpoint.conversationId,
+			threadId: validated.checkpoint.threadId,
 			reason: "digest-mismatch"
 		}) : storeError("save checkpoint", error)));
 		yield* hitFailpoint("save-checkpoint:after");
 	});
-	const loadCheckpoint = Effect.fn("DoConversationStore.loadCheckpoint")(function* (request) {
+	const loadCheckpoint = Effect.fn("DoThreadStore.loadCheckpoint")(function* (request) {
 		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(request).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", error)));
-		const conversation = yield* requireConversation(journal, validated.conversationId);
-		const rows = yield* journal.loadCheckpoint(validated.conversationId, validated.atOrBeforeSequence ?? conversation.tail_sequence).pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
+		const thread = yield* requireThread(journal, validated.threadId);
+		const rows = yield* journal.loadCheckpoint(validated.threadId, validated.atOrBeforeSequence ?? thread.tail_sequence).pipe(Effect.mapError((error) => storeError("load checkpoint", error)));
 		if (rows.length === 0) return Option.none();
-		if (rows.length !== 1) return yield* ConversationStoreError.make({
+		if (rows.length !== 1) return yield* ThreadStoreError.make({
 			operation: "load checkpoint",
 			message: `Expected at most one checkpoint row but found ${rows.length}.`
 		});
 		const checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
-		if ((yield* tailDigestAt(journal, checkpoint.conversationId, checkpoint.throughSequence)) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: checkpoint.conversationId,
+		if ((yield* tailDigestAt(journal, checkpoint.threadId, checkpoint.throughSequence)) !== checkpoint.tailDigest) return yield* CheckpointRejected.make({
+			threadId: checkpoint.threadId,
 			reason: "digest-mismatch"
 		});
 		return Option.some(checkpoint);
 	});
-	const conversationStore = ConversationStore.of({
+	const threadStore = ThreadStore.of({
 		append,
-		export: exportConversation,
+		export: exportThread,
 		inspectTail,
-		loadCheckpoint,
 		materialize,
 		observe,
 		read,
-		saveCheckpoint
+		checkpoints: {
+			save: saveCheckpoint,
+			load: loadCheckpoint
+		}
 	});
-	return Context.make(ConversationStore, conversationStore);
+	return Context.make(ThreadStore, threadStore);
 });
 /**
-* Durable Object Conversation Store implementation with configuration, failpoint, SQL, and
+* Durable Object Thread Store implementation with configuration, failpoint, SQL, and
 * Crypto authority kept visible in its input channel.
 */
-const conversationStoreLayer = Layer.effectContext(makeServices$2());
+const threadStoreLayer = Layer.effectContext(makeServices$2());
 /**
 * Validated Durable Object storage configuration Layer with the documented defaults applied.
-* Shared by the ConversationStore and SubmissionLedger convenience layers so their defaults
+* Shared by the ThreadStore and SubmissionLedger convenience layers so their defaults
 * cannot drift.
 */
 const storageConfigLayer = (options) => Layer.effect(DoStorageConfig)(Schema.decodeUnknownEffect(DoStorageConfigValue)({
@@ -1510,12 +1470,12 @@ const storageConfigLayer = (options) => Layer.effect(DoStorageConfig)(Schema.dec
 /** The failpoint Layer selected by convenience options: explicit handler or the no-op default. */
 const storageFailpointLayer = (options) => options.failpoint === void 0 ? DoStorageFailpoint.layer : Layer.succeed(DoStorageFailpoint)({ hit: options.failpoint });
 /**
-* A composition-root convenience Layer for canonical Conversations inside one Durable Object,
+* A composition-root convenience Layer for canonical Threads inside one Durable Object,
 * built over `ctx.storage`. Durable accepted work is served by the separate SubmissionLedger
 * port; point both at the SAME `ctx.storage` so claims fence the same producer epochs
 * (ADR-0011 D7's "same file" rule, transposed to one object's private database).
 */
-const layer = (options) => Layer.unwrap(Effect.map(DoStorageConfig, (config) => conversationStoreLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(DoStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
+const layer = (options) => Layer.unwrap(Effect.map(DoStorageConfig, (config) => threadStoreLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(DoStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
 /** Create an adapter-owned resumable observation offset for a known canonical sequence. */
 const observationOffsetAt = makeOffset;
 //#endregion
@@ -1537,7 +1497,7 @@ const WOKEN = "woken";
 const MAX_IDENTIFIER_LENGTH = 1024;
 var SubmissionRow = class extends Schema.Class("SubmissionRow")({
 	submission_id: BoundedIdentifier,
-	conversation_id: BoundedIdentifier,
+	thread_id: BoundedIdentifier,
 	queue_sequence: QueueSequence,
 	principal: BoundedIdentifier,
 	idempotency_key: BoundedIdentifier,
@@ -1625,7 +1585,7 @@ var MaxQueueSequenceRow = class extends Schema.Class("MaxQueueSequenceRow")({ ma
 var CanonicalRecordIdRow = class extends Schema.Class("CanonicalRecordIdRow")({ record_id: BoundedIdentifier }) {};
 const SUBMISSION_COLUMNS = `
   submission_id,
-  conversation_id,
+  thread_id,
   queue_sequence,
   principal,
   idempotency_key,
@@ -1662,7 +1622,7 @@ const CHILD_RESERVATION_COLUMNS = `
   release_began_at,
   released_at
 `;
-/** The branded ToolCallId schema, reached through the session port so no core import is needed. */
+/** The branded ToolCallId schema, reached through the thread port so no core import is needed. */
 const ToolCallIdSchema = ApprovalDecisionCommand.fields.toolCallId;
 const ToolCallIdList = Schema.Array(ToolCallIdSchema);
 const encodePersistedJsonText = Schema.encodeEffect(Schema.fromJsonString(PersistedJson));
@@ -1736,7 +1696,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		iso: new Date(millis).toISOString()
 	}));
 	const timestampMillis = (operation, rowKey) => (timestamp) => decodeUtcInstant(timestamp).pipe(Effect.map(DateTime.toEpochMillis), Effect.mapError((error) => corruptionFailure(operation, "effect_agent_submission_ownership", rowKey, error.message)));
-	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$1(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeSubmissionRows = (operation, rowKey, rows) => decodeRows$2(Schema.Array(SubmissionRow), "effect_agent_submissions", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readSubmission = Effect.fn("DoSubmissionLedger.readSubmission")(function* (operation, submissionId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
@@ -1767,23 +1727,23 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
       FROM effect_agent_submission_ownership
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$1(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(OwnershipRow), "effect_agent_submission_ownership", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submission_ownership", submissionId, "An ownership primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
-	const conversationEpoch = Effect.fn("DoSubmissionLedger.conversationEpoch")(function* (operation, conversationId) {
-		const conversations = yield* journal.getConversation(conversationId).pipe(Effect.mapError(internalFailure(operation)));
-		return conversations.length === 0 ? EPOCH_ZERO : conversations[0].producer_epoch;
+	const threadEpoch = Effect.fn("DoSubmissionLedger.threadEpoch")(function* (operation, threadId) {
+		const threads = yield* journal.getThread(threadId).pipe(Effect.mapError(internalFailure(operation)));
+		return threads.length === 0 ? EPOCH_ZERO : threads[0].producer_epoch;
 	});
 	/**
 	* Verify inside the surrounding write transaction that the presented token still owns the
 	* Submission's lane; a superseded or missing token fails with OwnershipLost carrying the
-	* Conversation's current producer epoch (DUR-006).
+	* Thread's current producer epoch (DUR-006).
 	*/
 	const requireOwnership = Effect.fn("DoSubmissionLedger.requireOwnership")(function* (operation, submission, ownershipToken) {
 		const ownership = yield* readOwnership(operation, submission.submission_id);
 		if (Option.isNone(ownership) || ownership.value.ownership_token !== ownershipToken) {
-			const actualEpoch = yield* conversationEpoch(operation, submission.conversation_id);
+			const actualEpoch = yield* threadEpoch(operation, submission.thread_id);
 			const submissionId = yield* Schema.decodeUnknownEffect(SubmissionSnapshot.fields.submissionId)(submission.submission_id).pipe(Effect.mapError(internalFailure(operation)));
 			return yield* OwnershipLost.make({
 				submissionId,
@@ -1798,7 +1758,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		if (row.parent_submission_id === null !== (row.parent_tool_call_id === null)) return yield* corruptionFailure(operation, "effect_agent_submissions", row.submission_id, "A parent linkage must record both the parent Submission and the parent Tool Call.");
 		return yield* decodeSubmissionSnapshotUnknown({
 			submissionId: row.submission_id,
-			conversationId: row.conversation_id,
+			threadId: row.thread_id,
 			queueSequence: row.queue_sequence,
 			principal: row.principal,
 			idempotencyKey: row.idempotency_key,
@@ -1832,7 +1792,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
       FROM effect_agent_settlement_reservations
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$1(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(ReservationRow), "effect_agent_settlement_reservations", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", submissionId, "A settlement reservation primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -1847,7 +1807,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
       FROM effect_agent_abort_intents
       WHERE submission_id = ${submissionId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeRows$1(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		const decoded = yield* decodeRows$2(Schema.Array(AbortIntentRow), "effect_agent_abort_intents", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_abort_intents", submissionId, "An abort intent primary key returned more than one row.");
 		return decoded.length === 0 ? Option.none() : Option.some(decoded[0]);
 	});
@@ -1867,7 +1827,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
         WHERE parent_submission_id = ${parentSubmissionId}
         ORDER BY child_submission_id ASC
       `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows$1(Schema.Array(ChildSettlementMarkerRow), "effect_agent_child_settlements", parentSubmissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$2(Schema.Array(ChildSettlementMarkerRow), "effect_agent_child_settlements", parentSubmissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	/**
 	* Whether one listed child is provably settled from THIS store: either its own row lives
@@ -1880,7 +1840,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		const childRow = yield* readSubmission(operation, childSubmissionId);
 		return Option.isSome(childRow) && childRow.value.state === "settled";
 	});
-	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$1(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
+	const decodeChildReservationRows = (operation, rowKey, rows) => decodeRows$2(Schema.Array(ChildReservationRow), "effect_agent_child_reservations", rowKey, rows).pipe(Effect.mapError(internalFailure(operation)));
 	const readChildReservation = Effect.fn("DoSubmissionLedger.readChildReservation")(function* (operation, reservationId) {
 		const rows = yield* sql`
       SELECT ${sql.literal(CHILD_RESERVATION_COLUMNS)}
@@ -1933,7 +1893,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
       WHERE submission_id = ${submissionId}
       ORDER BY tool_call_id ASC
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows$1(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$2(Schema.Array(ApprovalDecisionRow), "effect_agent_approval_decisions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const approvalIntentFromRow = Effect.fn("DoSubmissionLedger.approvalIntentFromRow")(function* (operation, row) {
 		return yield* decodeApprovalDecisionIntent({
@@ -1958,7 +1918,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
       WHERE submission_id = ${submissionId}
       ORDER BY tool_call_id ASC
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return yield* decodeRows$1(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
+		return yield* decodeRows$2(Schema.Array(UnknownResolutionRow), "effect_agent_unknown_resolutions", submissionId, rows).pipe(Effect.mapError(internalFailure(operation)));
 	});
 	const unknownResolutionIntentFromRow = Effect.fn("DoSubmissionLedger.unknownResolutionIntentFromRow")(function* (operation, row) {
 		const resolution = yield* parseStoredJsonText(row.resolution_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_unknown_resolutions", `${row.submission_id}/${row.tool_call_id}`, error.message)));
@@ -1981,18 +1941,18 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 	* derived from the shared canonical-records table using the deterministic abort record
 	* identity, never from a cached ledger marker.
 	*/
-	const canonicalAbortRecordId = Effect.fn("DoSubmissionLedger.canonicalAbortRecordId")(function* (operation, conversationId, submissionId) {
+	const canonicalAbortRecordId = Effect.fn("DoSubmissionLedger.canonicalAbortRecordId")(function* (operation, threadId, submissionId) {
 		const recordId = submissionAbortRecordId(submissionId);
 		const rows = yield* sql`
       SELECT record_id
       FROM effect_agent_canonical_records
-      WHERE conversation_id = ${conversationId}
+      WHERE thread_id = ${threadId}
         AND record_id = ${recordId}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		return (yield* decodeRows$1(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${conversationId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
+		return (yield* decodeRows$2(Schema.Array(CanonicalRecordIdRow), "effect_agent_canonical_records", `${threadId}/${recordId}`, rows).pipe(Effect.mapError(internalFailure(operation)))).length === 0 ? void 0 : recordId;
 	});
 	const abortIntentFromRow = Effect.fn("DoSubmissionLedger.abortIntentFromRow")(function* (operation, submission, submissionId, row) {
-		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, submissionId);
+		const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.thread_id, submissionId);
 		return yield* decodeAbortIntent({
 			submissionId: row.submission_id,
 			author: row.author,
@@ -2008,19 +1968,19 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(Effect.mapError(internalFailure(operation)));
 		yield* journal.checkValueBound(operation, inputJson).pipe(Effect.mapError(internalFailure(operation)));
 		const agentDigestsJson = yield* encodeDefinitionDigestsText(validated.agentDigests).pipe(Effect.mapError(internalFailure(operation)));
-		const mintedSubmissionId = `${yield* mintUuid(operation)}:${validated.conversationId}`;
+		const mintedSubmissionId = `${yield* mintUuid(operation)}:${validated.threadId}`;
 		if (mintedSubmissionId.length > MAX_IDENTIFIER_LENGTH) return yield* LedgerError.make({
 			operation,
-			message: `A routable Submission identity of ${mintedSubmissionId.length} characters exceeds the ${MAX_IDENTIFIER_LENGTH}-character ledger row bound; shorten the Conversation identity.`
+			message: `A routable Submission identity of ${mintedSubmissionId.length} characters exceeds the ${MAX_IDENTIFIER_LENGTH}-character ledger row bound; shorten the Thread identity.`
 		});
 		const mintedReceiptId = `receipt-${yield* mintUuid(operation)}`;
 		yield* hitFailpoint("ledger:admit:before", operation);
 		const result = yield* inWriteTransaction(operation, Effect.gen(function* () {
-			const keyRowKey = `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`;
+			const keyRowKey = `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`;
 			const existingRows = yield* sql`
             SELECT ${sql.literal(SUBMISSION_COLUMNS)}
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
               AND principal = ${validated.principal}
               AND idempotency_key = ${validated.idempotencyKey}
           `.pipe(Effect.mapError(sqlFailure(operation)));
@@ -2029,7 +1989,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 			if (existing.length === 1) {
 				const sameLinkage = validated.parentLinkage === void 0 ? existing[0].parent_submission_id === null && existing[0].parent_tool_call_id === null : existing[0].parent_submission_id === validated.parentLinkage.parentSubmissionId && existing[0].parent_tool_call_id === validated.parentLinkage.parentToolCallId;
 				if (existing[0].input_digest !== validated.inputDigest || !sameLinkage) return yield* AdmissionConflict.make({
-					conversationId: validated.conversationId,
+					threadId: validated.threadId,
 					principal: validated.principal,
 					idempotencyKey: validated.idempotencyKey,
 					existingInputDigest: existing[0].input_digest,
@@ -2046,15 +2006,15 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 			const maxRows = yield* sql`
             SELECT COALESCE(MAX(queue_sequence), 0) AS max_queue_sequence
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const decodedMax = yield* decodeRows$1(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.conversationId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
+			const decodedMax = yield* decodeRows$2(Schema.Array(MaxQueueSequenceRow), "effect_agent_submissions", validated.threadId, maxRows).pipe(Effect.mapError(internalFailure(operation)));
 			const queueSequence = yield* decodeQueueSequence((decodedMax[0]?.max_queue_sequence ?? 0) + 1).pipe(Effect.mapError(internalFailure(operation)));
 			const now = yield* currentInstant;
 			yield* sql`
             INSERT INTO effect_agent_submissions (
               submission_id,
-              conversation_id,
+              thread_id,
               queue_sequence,
               principal,
               idempotency_key,
@@ -2070,7 +2030,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
               parent_tool_call_id
             ) VALUES (
               ${mintedSubmissionId},
-              ${validated.conversationId},
+              ${validated.threadId},
               ${queueSequence},
               ${validated.principal},
               ${validated.idempotencyKey},
@@ -2123,12 +2083,12 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		const rows = yield* sql`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
+      WHERE thread_id = ${validated.threadId}
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
+		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, rows);
+		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
 		if (decoded.length === 0) return Option.none();
 		return Option.some(yield* decodeSubmissionSnapshot(operation, decoded[0]));
 	});
@@ -2138,12 +2098,12 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		const rows = yield* sql`
       SELECT ${sql.literal(SUBMISSION_COLUMNS)}
       FROM effect_agent_submissions
-      WHERE conversation_id = ${validated.conversationId}
+      WHERE thread_id = ${validated.threadId}
         AND principal = ${validated.principal}
         AND idempotency_key = ${validated.idempotencyKey}
     `.pipe(Effect.mapError(sqlFailure(operation)));
-		const decoded = yield* decodeSubmissionRows(operation, `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, rows);
-		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.conversationId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
+		const decoded = yield* decodeSubmissionRows(operation, `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, rows);
+		if (decoded.length > 1) return yield* corruptionFailure(operation, "effect_agent_submissions", `${validated.threadId}/${validated.principal}/${validated.idempotencyKey}`, "An admission idempotency key returned more than one row.");
 		if (decoded.length === 0) return AdmissionNotAdmitted.make();
 		return AdmissionAdmitted.make({ submission: yield* decodeSubmissionSnapshot(operation, decoded[0]) });
 	});
@@ -2157,12 +2117,12 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 			const headRows = yield* sql`
             SELECT ${sql.literal(SUBMISSION_COLUMNS)}
             FROM effect_agent_submissions
-            WHERE conversation_id = ${validated.conversationId}
+            WHERE thread_id = ${validated.threadId}
               AND state <> 'settled'
             ORDER BY queue_sequence ASC
             LIMIT 1
           `.pipe(Effect.mapError(sqlFailure(operation)));
-			const heads = yield* decodeSubmissionRows(operation, validated.conversationId, headRows);
+			const heads = yield* decodeSubmissionRows(operation, validated.threadId, headRows);
 			if (heads.length === 0) return Option.none();
 			const head = heads[0];
 			if (head.state === "joining" || head.state === "joined" || head.state === "suspended" || head.state === "unknown" && Option.isNone(yield* readAbortIntent(operation, head.submission_id))) return Option.none();
@@ -2171,19 +2131,19 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 			if (Option.isSome(ownership)) {
 				if ((yield* timestampMillis(operation, head.submission_id)(ownership.value.lease_expires_at)) > now.millis) return Option.none();
 			}
-			const conversations = yield* journal.getConversation(head.conversation_id).pipe(Effect.mapError(internalFailure(operation)));
+			const threads = yield* journal.getThread(head.thread_id).pipe(Effect.mapError(internalFailure(operation)));
 			let producerEpoch;
-			if (conversations.length === 0) {
+			if (threads.length === 0) {
 				producerEpoch = 1;
 				yield* sql`
-              INSERT INTO effect_agent_conversations (
-                conversation_id,
+              INSERT INTO effect_agent_threads (
+                thread_id,
                 created_at,
                 tail_sequence,
                 tail_digest,
                 producer_epoch
               ) VALUES (
-                ${head.conversation_id},
+                ${head.thread_id},
                 ${now.iso},
                 0,
                 ${EMPTY_TAIL_DIGEST},
@@ -2191,11 +2151,11 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
               )
             `.pipe(Effect.mapError(sqlFailure(operation)));
 			} else {
-				producerEpoch = conversations[0].producer_epoch + 1;
+				producerEpoch = threads[0].producer_epoch + 1;
 				yield* sql`
-              UPDATE effect_agent_conversations
+              UPDATE effect_agent_threads
               SET producer_epoch = ${producerEpoch}
-              WHERE conversation_id = ${head.conversation_id}
+              WHERE thread_id = ${head.thread_id}
             `.pipe(Effect.mapError(sqlFailure(operation)));
 			}
 			const leaseExpiresAt = new Date(now.millis + config.ownershipLeaseDuration).toISOString();
@@ -2226,14 +2186,14 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
             INSERT INTO effect_agent_attempts (
               attempt_id,
               submission_id,
-              conversation_id,
+              thread_id,
               owner_producer_id,
               producer_epoch,
               claimed_at
             ) VALUES (
               ${attemptId},
               ${head.submission_id},
-              ${head.conversation_id},
+              ${head.thread_id},
               ${validated.producerId},
               ${producerEpoch},
               ${now.iso}
@@ -2416,7 +2376,8 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 				submissionId: validated.submissionId,
 				existingOutcome: reservation.value.outcome
 			});
-			const settlementFailure = settlementFailureFromRecord(yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message))));
+			const reservationRecord = yield* decodeRecordEnvelopeText(reservation.value.record_json).pipe(Effect.mapError((error) => corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, error.message)));
+			const settlementFailure = settlementFailureFromRecord(reservationRecord);
 			if (reservation.value.outcome === "failed" !== (settlementFailure !== void 0)) return yield* corruptionFailure(operation, "effect_agent_settlement_reservations", validated.submissionId, "The reserved outcome and canonical failure diagnostic disagree.");
 			const submission = yield* requireSubmission(operation, validated.submissionId);
 			if (submission.state === "settled") {
@@ -2494,7 +2455,7 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
             ${now.iso}
           )
         `.pipe(Effect.mapError(sqlFailure(operation)));
-			const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.conversation_id, validated.submissionId);
+			const canonicalRecordId = yield* canonicalAbortRecordId(operation, submission.thread_id, validated.submissionId);
 			return yield* decodeAbortIntent({
 				submissionId: validated.submissionId,
 				author: validated.author,
@@ -2512,19 +2473,19 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 		yield* hitFailpoint("ledger:claim-joining:before", operation);
 		const claims = yield* inWriteTransaction(operation, Effect.gen(function* () {
 			const host = yield* requireSubmission(operation, validated.hostSubmissionId);
-			if (host.conversation_id !== validated.conversationId) return yield* LedgerError.make({
+			if (host.thread_id !== validated.threadId) return yield* LedgerError.make({
 				operation,
-				message: `Host submission ${validated.hostSubmissionId} does not belong to conversation ${validated.conversationId}.`
+				message: `Host submission ${validated.hostSubmissionId} does not belong to thread ${validated.threadId}.`
 			});
 			yield* requireOwnership(operation, host, validated.ownershipToken);
 			const laterRows = yield* sql`
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
-          WHERE conversation_id = ${validated.conversationId}
+          WHERE thread_id = ${validated.threadId}
             AND queue_sequence > ${host.queue_sequence}
           ORDER BY queue_sequence ASC
         `.pipe(Effect.mapError(sqlFailure(operation)));
-			const later = yield* decodeSubmissionRows(operation, validated.conversationId, laterRows);
+			const later = yield* decodeSubmissionRows(operation, validated.threadId, laterRows);
 			const claimed = [];
 			for (const row of later) {
 				if (claimed.length >= validated.maxCount) break;
@@ -3034,27 +2995,27 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
           WHERE state <> 'settled'
-          ORDER BY conversation_id ASC, queue_sequence ASC
+          ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         ` : sql`
           SELECT ${sql.literal(SUBMISSION_COLUMNS)}
           FROM effect_agent_submissions
           WHERE state <> 'settled'
             AND (
-              conversation_id > ${cursor.conversationId}
+              thread_id > ${cursor.threadId}
               OR (
-                conversation_id = ${cursor.conversationId}
+                thread_id = ${cursor.threadId}
                 AND queue_sequence > ${cursor.queueSequence}
               )
             )
-          ORDER BY conversation_id ASC, queue_sequence ASC
+          ORDER BY thread_id ASC, queue_sequence ASC
           LIMIT ${SCAN_PAGE_SIZE}
         `).pipe(Effect.mapError(sqlFailure(operation)));
 		const decoded = yield* decodeSubmissionRows(operation, "nonterminal_scan", rows);
 		const snapshots = yield* Effect.forEach(decoded, (row) => decodeSubmissionSnapshot(operation, row));
 		const last = decoded[decoded.length - 1];
 		return [snapshots, last === void 0 || decoded.length < SCAN_PAGE_SIZE ? Option.none() : Option.some({
-			conversationId: last.conversation_id,
+			threadId: last.thread_id,
 			queueSequence: last.queue_sequence
 		})];
 	});
@@ -3211,12 +3172,12 @@ const makeServices$1 = Effect.fn("DoSubmissionLedger.makeServices")(function* ()
 const submissionLedgerLayer = Layer.effectContext(makeServices$1());
 /**
 * A composition-root convenience Layer for the durable Submission Ledger. Point it at the
-* same `ctx.storage` as the ConversationStore so claims fence the same producer epochs.
+* same `ctx.storage` as the ThreadStore so claims fence the same producer epochs.
 */
 const ledgerLayer = (options) => Layer.unwrap(Effect.map(DoStorageConfig, (config) => submissionLedgerLayer.pipe(Layer.provide(Layer.mergeAll(Layer.succeed(DoStorageConfig)(config), storageFailpointLayer(options), SqliteClient.layer({ storage: options.storage }), BrowserCrypto.layer))))).pipe(Layer.provide(storageConfigLayer(options)));
 //#endregion
 //#region src/do-schedule-store.ts
-const CURRENT_SCHEDULE_STORE_VERSION = 1;
+const CURRENT_SCHEDULE_STORE_VERSION = 2;
 const StoredScheduleJson = Schema.String.check(Schema.isMaxLength(19e5));
 const StoredDeadline = Schema.NullOr(ScheduleInstant);
 var ScheduleRow = class extends Schema.Class("@effect-agent/storage-cloudflare/ScheduleRow")({
@@ -3246,26 +3207,26 @@ var ScheduleTableNameRow = class extends Schema.Class("@effect-agent/storage-clo
 var DoScheduleTransaction = class extends Context.Service()("@effect-agent/storage-cloudflare/DoScheduleTransaction") {};
 /** Platform driver operations that use the same schedule-state and alarm transaction. */
 var DoScheduleAlarmControl = class extends Context.Service()("@effect-agent/storage-cloudflare/DoScheduleAlarmControl") {};
-const unavailable = (operation) => ScheduleStorageError.make({
+const unavailable$1 = (operation) => ScheduleStorageError.make({
 	operation,
 	reason: "unavailable"
 });
-const corrupt = (operation) => ScheduleStorageError.make({
+const corrupt$1 = (operation) => ScheduleStorageError.make({
 	operation,
 	reason: "corrupt"
 });
-const decodeRows = Effect.fn("DoScheduleStore.decodeRows")(function* (schema, rows, operation) {
-	return yield* Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError(() => corrupt(operation)));
+const decodeRows$1 = Effect.fn("DoScheduleStore.decodeRows")(function* (schema, rows, operation) {
+	return yield* Schema.decodeUnknownEffect(schema)(rows).pipe(Effect.mapError(() => corrupt$1(operation)));
 });
-const decodeBoundary = (schema, value, operation) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => corrupt(operation)));
+const decodeBoundary = (schema, value, operation) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => corrupt$1(operation)));
 const decodeRecord = Effect.fn("DoScheduleStore.decodeRecord")(function* (row) {
-	const record = yield* Schema.decodeEffect(Schema.fromJsonString(ScheduleRecord))(row.record_json).pipe(Effect.mapError(() => corrupt("decode schedule")));
-	if (record.owner.tenantId !== row.tenant_id || record.owner.ownerId !== row.owner_id || record.scheduleId !== row.schedule_id || scheduleDeadline(record) !== row.deadline_at_millis) return yield* corrupt("decode schedule index");
+	const record = yield* Schema.decodeEffect(Schema.fromJsonString(ScheduleRecord))(row.record_json).pipe(Effect.mapError(() => corrupt$1("decode schedule")));
+	if (record.owner.tenantId !== row.tenant_id || record.owner.ownerId !== row.owner_id || record.scheduleId !== row.schedule_id || scheduleDeadline(record) !== row.deadline_at_millis) return yield* corrupt$1("decode schedule index");
 	return record;
 });
 const encodeRecord = Effect.fn("DoScheduleStore.encodeRecord")(function* (record) {
-	const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(ScheduleRecord))(record).pipe(Effect.mapError(() => corrupt("encode schedule")));
-	return yield* Schema.decodeUnknownEffect(StoredScheduleJson)(encoded).pipe(Effect.mapError(() => corrupt("encode schedule bounds")));
+	const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(ScheduleRecord))(record).pipe(Effect.mapError(() => corrupt$1("encode schedule")));
+	return yield* Schema.decodeUnknownEffect(StoredScheduleJson)(encoded).pipe(Effect.mapError(() => corrupt$1("encode schedule bounds")));
 });
 const initializeScheduleStore = Effect.fn("DoScheduleStore.initialize")(function* () {
 	const sql = yield* SqlClient.SqlClient;
@@ -3279,12 +3240,12 @@ const initializeScheduleStore = Effect.fn("DoScheduleStore.initialize")(function
         'effect_agent_schedules'
       )
     ORDER BY name
-  `.pipe(Effect.mapError(() => unavailable(operation)));
-	const tables = yield* decodeRows(Schema.Array(ScheduleTableNameRow), rawTables, operation);
+  `.pipe(Effect.mapError(() => unavailable$1(operation)));
+	const tables = yield* decodeRows$1(Schema.Array(ScheduleTableNameRow), rawTables, operation);
 	const hasState = tables.some((row) => row.name === "effect_agent_schedule_store_state");
 	const hasSchedules = tables.some((row) => row.name === "effect_agent_schedules");
 	if (!hasState) {
-		if (hasSchedules) return yield* corrupt(operation);
+		if (hasSchedules) return yield* corrupt$1(operation);
 		yield* sql.withTransaction(Effect.gen(function* () {
 			yield* sql`
             CREATE TABLE effect_agent_schedule_store_state (
@@ -3318,17 +3279,17 @@ const initializeScheduleStore = Effect.fn("DoScheduleStore.initialize")(function
               singleton, storage_version, alarm_generation
             ) VALUES (1, ${CURRENT_SCHEDULE_STORE_VERSION}, 0)
           `.withoutTransform;
-		})).pipe(Effect.mapError(() => unavailable(operation)));
+		})).pipe(Effect.mapError(() => unavailable$1(operation)));
 		return;
 	}
-	if (!hasSchedules) return yield* corrupt(operation);
+	if (!hasSchedules) return yield* corrupt$1(operation);
 	const rawState = yield* sql`
     SELECT storage_version, alarm_generation
     FROM effect_agent_schedule_store_state
     WHERE singleton = 1
-  `.pipe(Effect.mapError(() => unavailable(operation)));
-	const state = yield* decodeRows(Schema.Array(ScheduleStoreStateRow), rawState, operation);
-	if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt(operation);
+  `.pipe(Effect.mapError(() => unavailable$1(operation)));
+	const state = yield* decodeRows$1(Schema.Array(ScheduleStoreStateRow), rawState, operation);
+	if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt$1(state.length === 1 ? `${operation}: incompatible storage version ${state[0].storage_version}; expected ${CURRENT_SCHEDULE_STORE_VERSION}` : `${operation}: invalid storage version row`);
 });
 const makeServices = Effect.gen(function* () {
 	const sql = yield* SqlClient.SqlClient;
@@ -3342,13 +3303,13 @@ const makeServices = Effect.gen(function* () {
       WHERE tenant_id = ${key.owner.tenantId}
         AND owner_id = ${key.owner.ownerId}
         AND schedule_id = ${key.scheduleId}
-    `.pipe(Effect.mapError(() => unavailable(operation)));
-		return yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+    `.pipe(Effect.mapError(() => unavailable$1(operation)));
+		return yield* decodeRows$1(Schema.Array(ScheduleRow), rows, operation);
 	});
 	const readOne = Effect.fn("DoScheduleStore.readOne")(function* (key, operation) {
 		const rows = yield* readRows(key, operation);
 		if (rows.length === 0) return null;
-		if (rows.length !== 1) return yield* corrupt(operation);
+		if (rows.length !== 1) return yield* corrupt$1(operation);
 		return yield* decodeRecord(rows[0]);
 	});
 	const readNextDeadline = Effect.fn("DoScheduleStore.readNextDeadline")(function* (owner, operation) {
@@ -3356,15 +3317,15 @@ const makeServices = Effect.gen(function* () {
             SELECT MIN(deadline_at_millis) AS deadline_at_millis
             FROM effect_agent_schedules
             WHERE deadline_at_millis IS NOT NULL
-          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+          `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
             SELECT MIN(deadline_at_millis) AS deadline_at_millis
             FROM effect_agent_schedules
             WHERE tenant_id = ${owner.tenantId}
               AND owner_id = ${owner.ownerId}
               AND deadline_at_millis IS NOT NULL
-          `.pipe(Effect.mapError(() => unavailable(operation)));
-		const decoded = yield* decodeRows(Schema.Array(ScheduleDeadlineRow), rows, operation);
-		if (decoded.length !== 1) return yield* corrupt(operation);
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(ScheduleDeadlineRow), rows, operation);
+		if (decoded.length !== 1) return yield* corrupt$1(operation);
 		return decoded[0].deadline_at_millis;
 	});
 	const replaceAlarm = Effect.fn("DoScheduleStore.replaceAlarm")(function* (replace, deadlineAtMillis, operation) {
@@ -3373,9 +3334,9 @@ const makeServices = Effect.gen(function* () {
       SET alarm_generation = alarm_generation + 1
       WHERE singleton = 1
       RETURNING storage_version, alarm_generation
-    `.pipe(Effect.mapError(() => unavailable(operation)));
-		const state = yield* decodeRows(Schema.Array(ScheduleStoreStateRow), rawState, operation);
-		if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt(operation);
+    `.pipe(Effect.mapError(() => unavailable$1(operation)));
+		const state = yield* decodeRows$1(Schema.Array(ScheduleStoreStateRow), rawState, operation);
+		if (state.length !== 1 || state[0].storage_version !== CURRENT_SCHEDULE_STORE_VERSION) return yield* corrupt$1(operation);
 		yield* scheduleFailpoint.hit("schedule:alarm:before");
 		yield* replace({
 			deadlineAtMillis,
@@ -3406,9 +3367,9 @@ const makeServices = Effect.gen(function* () {
               AND owner_id = ${canonical.owner.ownerId}
               AND (json_extract(record_json, '$.pending') IS NOT NULL OR
                 (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
-          `.pipe(Effect.mapError(() => unavailable(operation)));
-			const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
-			if (counts.length !== 1) return yield* corrupt(operation);
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
+			const counts = yield* decodeRows$1(Schema.Array(ScheduleCountRow), rawCounts, operation);
+			if (counts.length !== 1) return yield* corrupt$1(operation);
 			if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
 			yield* scheduleFailpoint.hit("schedule:insert:before");
 			yield* sql`
@@ -3421,7 +3382,7 @@ const makeServices = Effect.gen(function* () {
               ${scheduleDeadline(canonical)},
               ${recordJson}
             )
-          `.pipe(Effect.mapError(() => unavailable(operation)));
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
 			const deadline = yield* readNextDeadline(void 0, operation);
 			yield* replaceAlarm(replace, deadline, operation);
 			return {
@@ -3446,7 +3407,7 @@ const makeServices = Effect.gen(function* () {
               AND owner_id = ${request.owner.ownerId}
             ORDER BY schedule_id
             LIMIT ${request.limit + 1}
-          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+          `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
             SELECT tenant_id, owner_id, schedule_id, deadline_at_millis, record_json
             FROM effect_agent_schedules
             WHERE tenant_id = ${request.owner.tenantId}
@@ -3454,8 +3415,8 @@ const makeServices = Effect.gen(function* () {
               AND schedule_id > ${request.after}
             ORDER BY schedule_id
             LIMIT ${request.limit + 1}
-          `.pipe(Effect.mapError(() => unavailable(operation)));
-		const decoded = yield* decodeRows(Schema.Array(ScheduleRow), rows, operation);
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
+		const decoded = yield* decodeRows$1(Schema.Array(ScheduleRow), rows, operation);
 		const records = yield* Effect.forEach(decoded, decodeRecord);
 		const hasNext = records.length > request.limit;
 		const items = hasNext ? records.slice(0, request.limit) : records;
@@ -3480,9 +3441,9 @@ const makeServices = Effect.gen(function* () {
               WHERE tenant_id = ${key.owner.tenantId} AND owner_id = ${key.owner.ownerId}
                 AND (json_extract(record_json, '$.pending') IS NOT NULL OR
                   (json_extract(record_json, '$.state') != 'cancelled' AND json_extract(record_json, '$.nextAtMillis') IS NOT NULL))
-            `.pipe(Effect.mapError(() => unavailable(operation)));
-				const counts = yield* decodeRows(Schema.Array(ScheduleCountRow), rawCounts, operation);
-				if (counts.length !== 1) return yield* corrupt(operation);
+            `.pipe(Effect.mapError(() => unavailable$1(operation)));
+				const counts = yield* decodeRows$1(Schema.Array(ScheduleCountRow), rawCounts, operation);
+				if (counts.length !== 1) return yield* corrupt$1(operation);
 				if (counts[0].schedule_count >= ownerLimit) return yield* ScheduleCapacityError.make({ limit: ownerLimit });
 			}
 			if (next === current) return {
@@ -3497,7 +3458,7 @@ const makeServices = Effect.gen(function* () {
             WHERE tenant_id = ${canonicalKey.owner.tenantId}
               AND owner_id = ${canonicalKey.owner.ownerId}
               AND schedule_id = ${canonicalKey.scheduleId}
-          `.pipe(Effect.mapError(() => unavailable(operation)));
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
 			const deadline = yield* readNextDeadline(void 0, operation);
 			yield* replaceAlarm(replace, deadline, operation);
 			return {
@@ -3510,7 +3471,7 @@ const makeServices = Effect.gen(function* () {
 	});
 	const due = Effect.fn("DoScheduleStore.due")(function* (nowMillis, limit, owner, after) {
 		const operation = "query due schedules";
-		const cursor = after === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(ScheduleDueCursor)(after).pipe(Effect.mapError(() => corrupt(operation)));
+		const cursor = after === void 0 ? void 0 : yield* Schema.decodeUnknownEffect(ScheduleDueCursor)(after).pipe(Effect.mapError(() => corrupt$1(operation)));
 		const continuation = cursor === void 0 ? sql`1 = 1` : sql`
       (deadline_at_millis, tenant_id, owner_id, schedule_id) >
       (${cursor.deadlineAtMillis}, ${cursor.owner.tenantId}, ${cursor.owner.ownerId}, ${cursor.scheduleId})`;
@@ -3520,7 +3481,7 @@ const makeServices = Effect.gen(function* () {
             WHERE deadline_at_millis <= ${nowMillis} AND ${continuation}
             ORDER BY deadline_at_millis, tenant_id, owner_id, schedule_id
             LIMIT ${limit}
-          `.pipe(Effect.mapError(() => unavailable(operation))) : yield* sql`
+          `.pipe(Effect.mapError(() => unavailable$1(operation))) : yield* sql`
             SELECT tenant_id, owner_id, schedule_id, deadline_at_millis
             FROM effect_agent_schedules
             WHERE tenant_id = ${owner.tenantId}
@@ -3528,8 +3489,8 @@ const makeServices = Effect.gen(function* () {
               AND deadline_at_millis <= ${nowMillis} AND ${continuation}
             ORDER BY deadline_at_millis, schedule_id
             LIMIT ${limit}
-          `.pipe(Effect.mapError(() => unavailable(operation)));
-		return (yield* decodeRows(Schema.Array(ScheduleDueRow), rows, operation)).map((row) => ({
+          `.pipe(Effect.mapError(() => unavailable$1(operation)));
+		return (yield* decodeRows$1(Schema.Array(ScheduleDueRow), rows, operation)).map((row) => ({
 			owner: {
 				tenantId: row.tenant_id,
 				ownerId: row.owner_id
@@ -3571,18 +3532,724 @@ const makeServices = Effect.gen(function* () {
 */
 const scheduleStoreLayer = Layer.effectContext(makeServices);
 //#endregion
+//#region src/do-subscription-store.ts
+const CURRENT_SUBSCRIPTION_STORE_VERSION = 2;
+const StoredJson = Schema.String.check(Schema.isMaxLength(19e5));
+const CountRow = Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) });
+const SequenceRow = Schema.Struct({ sequence: Schema.Natural });
+const ScanRow = Schema.Struct({
+	event_scan_cursor: Schema.String,
+	delivery_scan_cursor: Schema.String,
+	recovery_scan_cursor: Schema.Natural
+});
+const JsonRow = Schema.Struct({ record_json: StoredJson });
+const RegistrationRow = Schema.Struct({
+	owner_id: Schema.String,
+	subscription_id: Schema.String,
+	ordinal: Schema.Natural,
+	source_name: Schema.String,
+	source_version: Schema.String,
+	matching_key: Schema.String,
+	state: SubscriptionRecord.fields.state,
+	expires_at_millis: Schema.Number,
+	recovery_at_millis: Schema.NullOr(Schema.Number),
+	record_json: StoredJson
+});
+const EventRow = Schema.Struct({
+	event_id: Schema.String,
+	source_name: Schema.String,
+	source_version: Schema.String,
+	matching_key: Schema.String,
+	payload_digest: Digest,
+	cutoff: Schema.Natural,
+	cursor: Schema.Natural,
+	routing_complete: Schema.Number,
+	next_attempt_at_millis: Schema.Number,
+	record_json: StoredJson
+});
+const DeliveryRow = Schema.Struct({
+	owner_id: Schema.String,
+	subscription_id: Schema.String,
+	event_id: Schema.String,
+	delivery_key: Schema.String,
+	state: SubscriptionDelivery.fields.state,
+	next_attempt_at_millis: Schema.Number,
+	record_json: StoredJson
+});
+const StoreStateRow = Schema.Struct({
+	storage_version: Schema.Int,
+	alarm_generation: Schema.Natural
+});
+/** One Durable Object transaction combining subscription SQL and its single native alarm. */
+var DoSubscriptionTransaction = class extends Context.Service()("@effect-agent/storage-cloudflare/DoSubscriptionTransaction") {};
+var DoSubscriptionAlarmControl = class extends Context.Service()("@effect-agent/storage-cloudflare/DoSubscriptionAlarmControl") {};
+const error = (reason, code) => SubscriptionError.make({
+	reason,
+	code
+});
+const unavailable = (operation) => error("storage", operation);
+const corrupt = (operation) => error("corrupt", operation);
+const bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const validate = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error("validation", code)));
+const encode = (schema, value, code) => Schema.encodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => corrupt(code)));
+const decode = (schema, value, code) => Schema.decodeEffect(Schema.fromJsonString(schema))(value).pipe(Effect.mapError(() => corrupt(code)));
+const decodeRows = (schema, rows, code) => Schema.decodeUnknownEffect(Schema.Array(schema))(rows).pipe(Effect.mapError(() => corrupt(code)));
+const sameDeliveryIdentity = (left, right) => subscriptionDeliveryKeyString(left.key) === subscriptionDeliveryKeyString(right.key) && left.deliveryId === right.deliveryId && left.source.name === right.source.name && left.source.version === right.source.version && left.threadId === right.threadId && left.admissionKey === right.admissionKey && left.subscriptionFingerprint === right.subscriptionFingerprint && left.eventDigest === right.eventDigest;
+const initializeDoSubscriptionStore = Effect.fn("DoSubscriptionStore.initialize")(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const names = yield* sql`
+    SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'effect_agent_subscription_%'
+  `.pipe(Effect.mapError(() => unavailable("inspect subscription storage")));
+	const decodedNames = yield* decodeRows(Schema.Struct({ name: Schema.String }), names, "inspect subscription storage");
+	const expected = /* @__PURE__ */ new Set([
+		"effect_agent_subscription_store_state",
+		"effect_agent_subscription_sequences",
+		"effect_agent_subscriptions",
+		"effect_agent_subscription_events",
+		"effect_agent_subscription_deliveries"
+	]);
+	const hasState = decodedNames.some(({ name }) => name === "effect_agent_subscription_store_state");
+	if (!hasState && decodedNames.length > 0) return yield* corrupt("partial subscription storage");
+	if (!hasState) {
+		yield* sql.withTransaction(Effect.gen(function* () {
+			yield* sql`CREATE TABLE effect_agent_subscription_store_state (
+        singleton INTEGER PRIMARY KEY NOT NULL CHECK(singleton=1), storage_version INTEGER NOT NULL, alarm_generation INTEGER NOT NULL
+      )`.withoutTransform;
+			yield* sql`CREATE TABLE effect_agent_subscription_sequences (
+        tenant_id TEXT NOT NULL, source_address TEXT NOT NULL, sequence INTEGER NOT NULL,
+        event_scan_cursor TEXT NOT NULL, delivery_scan_cursor TEXT NOT NULL, recovery_scan_cursor INTEGER NOT NULL,
+        PRIMARY KEY (tenant_id, source_address)
+      )`.withoutTransform;
+			yield* sql`CREATE TABLE effect_agent_subscriptions (
+        tenant_id TEXT NOT NULL, source_address TEXT NOT NULL, owner_id TEXT NOT NULL, subscription_id TEXT NOT NULL,
+        ordinal INTEGER NOT NULL, source_name TEXT NOT NULL, source_version TEXT NOT NULL, matching_key TEXT NOT NULL,
+        state TEXT NOT NULL, expires_at_millis INTEGER NOT NULL, recovery_at_millis INTEGER, record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id), UNIQUE (tenant_id, source_address, ordinal)
+      )`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscriptions_owner ON effect_agent_subscriptions (tenant_id, source_address, owner_id, ordinal)`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscriptions_candidates ON effect_agent_subscriptions (tenant_id, source_address, source_name, source_version, matching_key, ordinal)`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscriptions_recovery ON effect_agent_subscriptions (tenant_id, source_address, recovery_at_millis, ordinal) WHERE recovery_at_millis IS NOT NULL`.withoutTransform;
+			yield* sql`CREATE TABLE effect_agent_subscription_events (
+        tenant_id TEXT NOT NULL, source_address TEXT NOT NULL, event_id TEXT NOT NULL, source_name TEXT NOT NULL,
+        source_version TEXT NOT NULL, matching_key TEXT NOT NULL, payload_digest TEXT NOT NULL, cutoff INTEGER NOT NULL,
+        cursor INTEGER NOT NULL, routing_complete INTEGER NOT NULL, next_attempt_at_millis INTEGER NOT NULL, record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, source_address, event_id)
+      )`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscription_events_pending ON effect_agent_subscription_events (tenant_id, source_address, routing_complete, next_attempt_at_millis, event_id)`.withoutTransform;
+			yield* sql`CREATE TABLE effect_agent_subscription_deliveries (
+        tenant_id TEXT NOT NULL, source_address TEXT NOT NULL, owner_id TEXT NOT NULL, subscription_id TEXT NOT NULL,
+        event_id TEXT NOT NULL, delivery_key TEXT NOT NULL, state TEXT NOT NULL, next_attempt_at_millis INTEGER NOT NULL,
+        record_json TEXT NOT NULL, PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id, event_id),
+        UNIQUE (tenant_id, source_address, delivery_key)
+      )`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscription_deliveries_pending ON effect_agent_subscription_deliveries (tenant_id, source_address, state, next_attempt_at_millis, delivery_key)`.withoutTransform;
+			yield* sql`CREATE INDEX effect_agent_subscription_deliveries_registration ON effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, delivery_key)`.withoutTransform;
+			yield* sql`INSERT INTO effect_agent_subscription_store_state (singleton, storage_version, alarm_generation)
+        VALUES (1, ${CURRENT_SUBSCRIPTION_STORE_VERSION}, 0)`.withoutTransform;
+		})).pipe(Effect.mapError(() => unavailable("initialize subscription storage")));
+		return;
+	}
+	if (decodedNames.length !== expected.size || decodedNames.some(({ name }) => !expected.has(name))) return yield* corrupt("subscription storage tables");
+	const rows = yield* sql`SELECT storage_version, alarm_generation FROM effect_agent_subscription_store_state WHERE singleton=1`.pipe(Effect.mapError(() => unavailable("read subscription storage version")));
+	const state = yield* decodeRows(StoreStateRow, rows, "read subscription storage version");
+	if (state.length !== 1 || state[0].storage_version !== CURRENT_SUBSCRIPTION_STORE_VERSION) return yield* corrupt(state.length === 1 ? `incompatible subscription storage version ${state[0].storage_version}; expected ${CURRENT_SUBSCRIPTION_STORE_VERSION}` : "invalid subscription storage version row");
+});
+const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function* (owned) {
+	const partition = yield* validate(SourcePartition, owned, "partition");
+	const sql = yield* SqlClient.SqlClient;
+	const failpoint = yield* SubscriptionFailpoint;
+	const transactions = yield* DoSubscriptionTransaction;
+	yield* initializeDoSubscriptionStore();
+	yield* sql`
+    INSERT INTO effect_agent_subscription_sequences (
+      tenant_id, source_address, sequence, event_scan_cursor, delivery_scan_cursor, recovery_scan_cursor
+    ) VALUES (${partition.tenantId}, ${partition.address}, 0, '', '', 0) ON CONFLICT DO NOTHING
+  `.pipe(Effect.mapError(() => unavailable("initialize subscription partition")));
+	const query = (effect, code) => effect.pipe(Effect.mapError(() => unavailable(code)));
+	const readIndexedDeadline = Effect.fn("DoSubscriptionStore.readIndexedDeadline")(function* () {
+		const scanRows = yield* query(sql`
+      SELECT event_scan_cursor, delivery_scan_cursor, recovery_scan_cursor FROM effect_agent_subscription_sequences
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+    `, "read scan cursor deadline");
+		const scans = yield* decodeRows(ScanRow, scanRows, "read scan cursor deadline");
+		if (scans.length !== 1) return yield* corrupt("scan cursor deadline");
+		if (scans[0].event_scan_cursor !== "" || scans[0].delivery_scan_cursor !== "" || scans[0].recovery_scan_cursor !== 0) return 0;
+		const rows = yield* query(sql`
+      SELECT MIN(deadline) AS deadline FROM (
+        SELECT next_attempt_at_millis AS deadline FROM effect_agent_subscription_events
+          WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND routing_complete=0
+        UNION ALL SELECT next_attempt_at_millis FROM effect_agent_subscription_deliveries
+          WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state NOT IN ('delivered','refused')
+        UNION ALL SELECT recovery_at_millis FROM effect_agent_subscriptions
+          WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state='active' AND recovery_at_millis IS NOT NULL
+      )
+    `, "read subscription deadline");
+		const decoded = yield* decodeRows(Schema.Struct({ deadline: Schema.NullOr(Schema.Number) }), rows, "read subscription deadline");
+		if (decoded.length !== 1) return yield* corrupt("subscription deadline");
+		return decoded[0].deadline;
+	});
+	const replaceAlarm = Effect.fn("DoSubscriptionStore.replaceAlarm")(function* (replace, deadlineAtMillis) {
+		const rows = yield* query(sql`
+      UPDATE effect_agent_subscription_store_state SET alarm_generation=alarm_generation+1
+      WHERE singleton=1 RETURNING storage_version, alarm_generation
+    `, "advance subscription alarm generation");
+		const state = yield* decodeRows(StoreStateRow, rows, "advance subscription alarm generation");
+		if (state.length !== 1 || state[0].storage_version !== CURRENT_SUBSCRIPTION_STORE_VERSION) return yield* corrupt("subscription alarm state");
+		yield* failpoint.hit("subscription:alarm:before");
+		yield* replace({
+			deadlineAtMillis,
+			generation: state[0].alarm_generation
+		});
+		yield* failpoint.hit("subscription:alarm:after");
+	});
+	const transact = (effect) => transactions.run((replace) => Effect.gen(function* () {
+		const value = yield* effect;
+		yield* replaceAlarm(replace, yield* readIndexedDeadline());
+		return value;
+	}));
+	const requirePartition = (candidate, code) => sameSourcePartition(candidate, partition) ? Effect.void : Effect.fail(error("validation", code));
+	const requireKey = Effect.fn("SqliteSubscriptionStore.requireKey")(function* (input, code) {
+		const key = yield* validate(SubscriptionKey, input, code);
+		yield* requirePartition(key.partition, code);
+		return key;
+	});
+	const readRegistration = Effect.fn("SqliteSubscriptionStore.readRegistration")(function* (key, code) {
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, ordinal, source_name, source_version, matching_key, state,
+        expires_at_millis, recovery_at_millis, record_json FROM effect_agent_subscriptions
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${key.ownerId} AND subscription_id=${key.subscriptionId}
+    `, code);
+		const decodedRows = yield* decodeRows(RegistrationRow, rows, code);
+		if (decodedRows.length > 1) return yield* corrupt(code);
+		const row = decodedRows[0];
+		if (row === void 0) return null;
+		const record = yield* decode(SubscriptionRecord, row.record_json, code);
+		if (!sameSourcePartition(record.key.partition, partition) || record.key.ownerId !== row.owner_id || record.key.subscriptionId !== row.subscription_id || record.ordinal !== row.ordinal || record.configuration.source.name !== row.source_name || record.configuration.source.version !== row.source_version || record.configuration.matchingKey !== row.matching_key || record.state !== row.state || record.configuration.expiresAtMillis !== row.expires_at_millis || (record.recovery?.nextAttemptAtMillis ?? null) !== row.recovery_at_millis) return yield* corrupt(`${code}-projection`);
+		return record;
+	});
+	const readEvent = Effect.fn("SqliteSubscriptionStore.readEvent")(function* (eventId, code) {
+		const rows = yield* query(sql`
+      SELECT event_id, source_name, source_version, matching_key, payload_digest, cutoff, cursor,
+        routing_complete, next_attempt_at_millis, record_json FROM effect_agent_subscription_events
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND event_id=${eventId}
+    `, code);
+		const decodedRows = yield* decodeRows(EventRow, rows, code);
+		if (decodedRows.length > 1) return yield* corrupt(code);
+		const row = decodedRows[0];
+		if (row === void 0) return null;
+		const event = yield* decode(AcceptedEvent, row.record_json, code);
+		if (!sameSourcePartition(event.partition, partition) || event.eventId !== row.event_id || event.source.name !== row.source_name || event.source.version !== row.source_version || event.matchingKey !== row.matching_key || event.payloadDigest !== row.payload_digest || event.cutoff !== row.cutoff || event.cursor !== row.cursor || (event.routingComplete ? 1 : 0) !== row.routing_complete || event.nextAttemptAtMillis !== row.next_attempt_at_millis) return yield* corrupt(`${code}-projection`);
+		return event;
+	});
+	const readDelivery = Effect.fn("SqliteSubscriptionStore.readDelivery")(function* (key, code) {
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, event_id, delivery_key, state, next_attempt_at_millis, record_json
+      FROM effect_agent_subscription_deliveries
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${key.subscription.ownerId} AND subscription_id=${key.subscription.subscriptionId}
+        AND event_id=${key.eventId}
+    `, code);
+		const decodedRows = yield* decodeRows(DeliveryRow, rows, code);
+		if (decodedRows.length > 1) return yield* corrupt(code);
+		const row = decodedRows[0];
+		if (row === void 0) return null;
+		const delivery = yield* decode(SubscriptionDelivery, row.record_json, code);
+		if (!sameSourcePartition(delivery.key.subscription.partition, partition) || delivery.key.subscription.ownerId !== row.owner_id || delivery.key.subscription.subscriptionId !== row.subscription_id || delivery.key.eventId !== row.event_id || subscriptionDeliveryKeyString(delivery.key) !== row.delivery_key || delivery.state !== row.state || delivery.retry.nextAttemptAtMillis !== row.next_attempt_at_millis) return yield* corrupt(`${code}-projection`);
+		return delivery;
+	});
+	const count = Effect.fn("SqliteSubscriptionStore.count")(function* (statement, code) {
+		const rows = yield* query(statement, code);
+		const decoded = yield* decodeRows(CountRow, rows, code);
+		if (decoded.length !== 1) return yield* corrupt(code);
+		return decoded[0].count;
+	});
+	const nextSequence = Effect.fn("SqliteSubscriptionStore.nextSequence")(function* () {
+		const rows = yield* query(sql`
+      UPDATE effect_agent_subscription_sequences SET sequence=sequence+1
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+      RETURNING sequence
+    `, "advance subscription sequence");
+		const decoded = yield* decodeRows(SequenceRow, rows, "advance subscription sequence");
+		if (decoded.length !== 1) return yield* corrupt("subscription sequence");
+		return decoded[0].sequence;
+	});
+	const writeRegistration = Effect.fn("SqliteSubscriptionStore.writeRegistration")(function* (record) {
+		const json = yield* encode(SubscriptionRecord, record, "encode subscription");
+		yield* query(sql`
+      UPDATE effect_agent_subscriptions SET state=${record.state}, expires_at_millis=${record.configuration.expiresAtMillis},
+        recovery_at_millis=${record.recovery?.nextAttemptAtMillis ?? null}, record_json=${json}
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${record.key.ownerId} AND subscription_id=${record.key.subscriptionId}
+    `, "write subscription");
+	});
+	const writeEvent = Effect.fn("SqliteSubscriptionStore.writeEvent")(function* (event) {
+		const json = yield* encode(AcceptedEvent, event, "encode event");
+		yield* query(sql`
+      UPDATE effect_agent_subscription_events SET cursor=${event.cursor}, routing_complete=${event.routingComplete ? 1 : 0},
+        next_attempt_at_millis=${event.nextAttemptAtMillis}, record_json=${json}
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND event_id=${event.eventId}
+    `, "write event");
+	});
+	const writeDelivery = Effect.fn("SqliteSubscriptionStore.writeDelivery")(function* (delivery) {
+		const json = yield* encode(SubscriptionDelivery, delivery, "encode delivery");
+		yield* query(sql`
+      UPDATE effect_agent_subscription_deliveries SET state=${delivery.state},
+        next_attempt_at_millis=${delivery.retry.nextAttemptAtMillis}, record_json=${json}
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${delivery.key.subscription.ownerId} AND subscription_id=${delivery.key.subscription.subscriptionId}
+        AND event_id=${delivery.key.eventId}
+    `, "write delivery");
+	});
+	const register = Effect.fn("SqliteSubscriptionStore.register")(function* (input, inputLimits) {
+		const record = yield* validate(SubscriptionRecord, input, "register-record");
+		const limits = yield* validate(SubscriptionLimits, inputLimits, "register-limits");
+		yield* requirePartition(record.key.partition, "register-partition");
+		const result = yield* transact(Effect.gen(function* () {
+			const existing = yield* readRegistration(record.key, "register-existing");
+			if (existing !== null) {
+				if (existing.creationFingerprint !== record.creationFingerprint) return yield* error("conflict", "registration-identity");
+				return {
+					value: existing,
+					changed: false
+				};
+			}
+			if (bytes(record.configuration.context) > limits.maxContextBytes) return yield* error("capacity", "context-bytes");
+			if (bytes(record.configuration.parameters) > limits.maxPayloadBytes) return yield* error("capacity", "parameters-bytes");
+			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return yield* error("capacity", "lifetime");
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count registrations")) >= limits.maxRegistrations) return yield* error("capacity", "registrations");
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${record.key.ownerId}`, "count owner registrations")) >= limits.maxRegistrationsPerOwner) return yield* error("capacity", "owner-registrations");
+			const assigned = {
+				...record,
+				ordinal: yield* nextSequence()
+			};
+			const json = yield* encode(SubscriptionRecord, assigned, "encode registration");
+			yield* failpoint.hit("subscription:register:before");
+			yield* query(sql`
+        INSERT INTO effect_agent_subscriptions (tenant_id, source_address, owner_id, subscription_id, ordinal,
+          source_name, source_version, matching_key, state, expires_at_millis, recovery_at_millis, record_json)
+        VALUES (${partition.tenantId}, ${partition.address}, ${assigned.key.ownerId}, ${assigned.key.subscriptionId}, ${assigned.ordinal},
+          ${assigned.configuration.source.name}, ${assigned.configuration.source.version}, ${assigned.configuration.matchingKey}, ${assigned.state},
+          ${assigned.configuration.expiresAtMillis}, ${assigned.recovery?.nextAttemptAtMillis ?? null}, ${json})
+      `, "insert registration");
+			return {
+				value: assigned,
+				changed: true
+			};
+		}));
+		if (result.changed) yield* failpoint.hit("subscription:register:after");
+		return result.value;
+	});
+	const get = Effect.fn("SqliteSubscriptionStore.get")(function* (input) {
+		return yield* readRegistration(yield* requireKey(input, "get-key"), "get subscription");
+	});
+	const list = Effect.fn("SqliteSubscriptionStore.list")(function* (ownerId, after, limit) {
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${ownerId} AND ordinal>${after} ORDER BY ordinal LIMIT ${limit}
+    `, "list subscriptions");
+		const decoded = yield* decodeRows(Schema.Struct({
+			owner_id: Schema.String,
+			subscription_id: Schema.String,
+			ordinal: Schema.Natural
+		}), rows, "list subscriptions");
+		return yield* Effect.forEach(decoded, Effect.fn("SqliteSubscriptionStore.listRecord")(function* (row) {
+			const record = yield* readRegistration({
+				partition,
+				ownerId: row.owner_id,
+				subscriptionId: row.subscription_id
+			}, "list subscription");
+			if (record === null || record.ordinal !== row.ordinal) return yield* corrupt("list subscription projection");
+			return record;
+		}));
+	});
+	const cancel = Effect.fn("SqliteSubscriptionStore.cancel")(function* (input) {
+		const key = yield* requireKey(input, "cancel-key");
+		const result = yield* transact(Effect.gen(function* () {
+			const current = yield* readRegistration(key, "cancel subscription");
+			if (current === null) return yield* error("not-found", "subscription");
+			if (current.state === "cancelled") return {
+				value: current,
+				changed: false
+			};
+			const updated = {
+				...current,
+				state: "cancelled",
+				recovery: null
+			};
+			yield* failpoint.hit("subscription:cancel:before");
+			yield* writeRegistration(updated);
+			return {
+				value: updated,
+				changed: true
+			};
+		}));
+		if (result.changed) yield* failpoint.hit("subscription:cancel:after");
+		return result.value;
+	});
+	const accept = Effect.fn("SqliteSubscriptionStore.accept")(function* (input, inputLimits) {
+		const event = yield* validate(AcceptedEvent, input, "accept-event");
+		const limits = yield* validate(SubscriptionLimits, inputLimits, "accept-limits");
+		yield* requirePartition(event.partition, "accept-partition");
+		const result = yield* transact(Effect.gen(function* () {
+			const existing = yield* readEvent(event.eventId, "accept event");
+			if (existing !== null) {
+				if (!sameAcceptedEventIdentity(existing, event)) return yield* error("conflict", "event-identity");
+				return {
+					value: existing,
+					changed: false
+				};
+			}
+			if (bytes(event.payload) > limits.maxPayloadBytes) return yield* error("capacity", "payload-bytes");
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_events WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count events")) >= limits.maxEvents) return yield* error("capacity", "events");
+			const accepted = {
+				...event,
+				cutoff: yield* nextSequence(),
+				cursor: 0,
+				routingComplete: false,
+				routingFailure: null
+			};
+			const json = yield* encode(AcceptedEvent, accepted, "encode accepted event");
+			yield* failpoint.hit("subscription:accept:before");
+			yield* query(sql`
+        INSERT INTO effect_agent_subscription_events (tenant_id, source_address, event_id, source_name, source_version,
+          matching_key, payload_digest, cutoff, cursor, routing_complete, next_attempt_at_millis, record_json)
+        VALUES (${partition.tenantId}, ${partition.address}, ${accepted.eventId}, ${accepted.source.name}, ${accepted.source.version},
+          ${accepted.matchingKey}, ${accepted.payloadDigest}, ${accepted.cutoff}, ${accepted.cursor}, 0, ${accepted.nextAttemptAtMillis}, ${json})
+      `, "insert event");
+			return {
+				value: accepted,
+				changed: true
+			};
+		}));
+		if (result.changed) yield* failpoint.hit("subscription:accept:after");
+		return result.value;
+	});
+	const event = Effect.fn("SqliteSubscriptionStore.event")((eventId) => readEvent(eventId, "get event"));
+	const pendingEvents = Effect.fn("SqliteSubscriptionStore.pendingEvents")(function* (nowMillis, after, limit) {
+		const rows = yield* query(sql`
+      SELECT event_id FROM effect_agent_subscription_events WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND routing_complete=0 AND next_attempt_at_millis<=${nowMillis} AND event_id>${after} ORDER BY event_id LIMIT ${limit}
+    `, "pending events");
+		return yield* decodeRows(Schema.Struct({ event_id: Schema.String }), rows, "pending event keys").pipe(Effect.map((items) => items.map((item) => item.event_id)));
+	});
+	const candidates = Effect.fn("SqliteSubscriptionStore.candidates")(function* (input, limit) {
+		const supplied = yield* validate(AcceptedEvent, input, "candidates-event");
+		yield* requirePartition(supplied.partition, "candidates-partition");
+		const stored = yield* readEvent(supplied.eventId, "candidates event");
+		if (stored === null) return yield* error("not-found", "event");
+		if (!sameAcceptedEventIdentity(stored, supplied)) return yield* error("conflict", "event");
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND source_name=${stored.source.name} AND source_version=${stored.source.version} AND matching_key=${stored.matchingKey}
+        AND ordinal>${stored.cursor} AND ordinal<=${stored.cutoff} ORDER BY ordinal LIMIT ${limit}
+    `, "subscription candidates");
+		const decoded = yield* decodeRows(Schema.Struct({
+			owner_id: Schema.String,
+			subscription_id: Schema.String,
+			ordinal: Schema.Natural
+		}), rows, "subscription candidates");
+		return yield* Effect.forEach(decoded, Effect.fn("SqliteSubscriptionStore.candidateRecord")(function* (row) {
+			const record = yield* readRegistration({
+				partition,
+				ownerId: row.owner_id,
+				subscriptionId: row.subscription_id
+			}, "subscription candidate");
+			if (record === null || record.ordinal !== row.ordinal) return yield* corrupt("subscription candidate projection");
+			return record;
+		}));
+	});
+	const insertDelivery = Effect.fn("SqliteSubscriptionStore.insertDelivery")(function* (delivery) {
+		const json = yield* encode(SubscriptionDelivery, delivery, "encode selected delivery");
+		yield* query(sql`
+      INSERT INTO effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, event_id,
+        delivery_key, state, next_attempt_at_millis, record_json)
+      VALUES (${partition.tenantId}, ${partition.address}, ${delivery.key.subscription.ownerId}, ${delivery.key.subscription.subscriptionId},
+        ${delivery.key.eventId}, ${subscriptionDeliveryKeyString(delivery.key)}, ${delivery.state}, ${delivery.retry.nextAttemptAtMillis}, ${json})
+    `, "insert delivery");
+	});
+	const select = Effect.fn("SqliteSubscriptionStore.select")(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
+		const supplied = yield* validate(AcceptedEvent, inputEvent, "select-event");
+		const deliveries = yield* validate(Schema.Array(SubscriptionDelivery), inputDeliveries, "select-deliveries");
+		const limits = yield* validate(SubscriptionLimits, inputLimits, "select-limits");
+		yield* requirePartition(supplied.partition, "select-partition");
+		for (const candidate of deliveries) yield* requirePartition(candidate.key.subscription.partition, "select-delivery-partition");
+		if (yield* transact(Effect.gen(function* () {
+			const accepted = yield* readEvent(supplied.eventId, "select event");
+			if (accepted === null) return yield* error("not-found", "event");
+			if (!sameAcceptedEventIdentity(accepted, supplied) || accepted.cursor !== supplied.cursor) return yield* error("conflict", "event-cursor");
+			if (accepted.routingComplete) return false;
+			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return yield* error("validation", "cursor");
+			yield* failpoint.hit("subscription:select:before");
+			const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+			const additions = [];
+			for (const delivery of deliveries) {
+				const record = yield* readRegistration(delivery.key.subscription, "select registration");
+				if (record === null) return yield* error("not-found", "subscription");
+				if (!subscriptionDeliveryCanSelect(delivery, record, accepted) || delivery.key.eventId !== accepted.eventId || delivery.source.name !== accepted.source.name || delivery.source.version !== accepted.source.version || record.ordinal <= accepted.cursor || record.ordinal > cursor) return yield* error("conflict", "selection");
+				const existing = yield* readDelivery(delivery.key, "select existing delivery");
+				if (existing !== null) {
+					if (!sameDeliveryIdentity(existing, delivery)) return yield* error("conflict", "delivery-identity");
+					continue;
+				}
+				if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, false)) continue;
+				additions.push({
+					delivery,
+					record
+				});
+			}
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count deliveries")) + additions.length > limits.maxDeliveries) return yield* error("capacity", "deliveries");
+			for (const ownerId of new Set(additions.map(({ record }) => record.key.ownerId))) if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${ownerId}`, "count owner deliveries")) + additions.filter(({ record }) => record.key.ownerId === ownerId).length > limits.maxDeliveriesPerOwner) return yield* error("capacity", "owner-deliveries");
+			for (const addition of additions) {
+				yield* insertDelivery(addition.delivery);
+				if (addition.record.configuration.mode === "once") yield* writeRegistration({
+					...addition.record,
+					state: "consumed",
+					recovery: null
+				});
+			}
+			yield* writeEvent({
+				...accepted,
+				cursor,
+				routingComplete: complete,
+				routingFailure: null
+			});
+			return true;
+		}))) yield* failpoint.hit("subscription:select:after");
+	});
+	const catchUp = Effect.fn("SqliteSubscriptionStore.catchUp")(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
+		const supplied = yield* validate(AcceptedEvent, inputEvent, "catch-up-event");
+		const delivery = yield* validate(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
+		const limits = yield* validate(SubscriptionLimits, inputLimits, "catch-up-limits");
+		yield* requirePartition(supplied.partition, "catch-up-partition");
+		yield* requirePartition(delivery.key.subscription.partition, "catch-up-delivery-partition");
+		if (yield* transact(Effect.gen(function* () {
+			const accepted = yield* readEvent(supplied.eventId, "catch-up event");
+			const record = yield* readRegistration(delivery.key.subscription, "catch-up subscription");
+			if (accepted === null || record === null) return yield* error("not-found", accepted === null ? "event" : "subscription");
+			if (!sameAcceptedEventIdentity(accepted, supplied) || !subscriptionDeliveryCanSelect(delivery, record, accepted) || delivery.key.eventId !== accepted.eventId || delivery.source.name !== accepted.source.name || delivery.source.version !== accepted.source.version || record.configuration.mode !== "once") return yield* error("conflict", "catch-up-identity");
+			const existing = yield* readDelivery(delivery.key, "catch-up existing delivery");
+			if (existing !== null) {
+				if (!sameDeliveryIdentity(existing, delivery)) return yield* error("conflict", "delivery-identity");
+				return false;
+			}
+			yield* failpoint.hit("subscription:catch-up:before");
+			const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+			if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, true)) return yield* error("conflict", "catch-up-eligibility");
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`, "count deliveries")) >= limits.maxDeliveries) return yield* error("capacity", "deliveries");
+			if ((yield* count(sql`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${record.key.ownerId}`, "count owner deliveries")) >= limits.maxDeliveriesPerOwner) return yield* error("capacity", "owner-deliveries");
+			yield* insertDelivery(delivery);
+			yield* writeRegistration({
+				...record,
+				state: "consumed",
+				recovery: null
+			});
+			return true;
+		}))) yield* failpoint.hit("subscription:catch-up:after");
+	});
+	const deferEvent = Effect.fn("SqliteSubscriptionStore.deferEvent")(function* (eventId, nextAttemptAtMillis, code) {
+		const routingFailure = code === void 0 ? "routing-failed" : yield* validate(SubscriptionName, code, "routing-failure");
+		yield* transact(Effect.gen(function* () {
+			const accepted = yield* readEvent(eventId, "defer event");
+			if (accepted === null) return yield* error("not-found", "event");
+			yield* failpoint.hit("subscription:defer-event:before");
+			yield* writeEvent({
+				...accepted,
+				nextAttemptAtMillis,
+				routingFailure
+			});
+		}));
+		yield* failpoint.hit("subscription:defer-event:after");
+	});
+	const delivery = Effect.fn("SqliteSubscriptionStore.delivery")(function* (input) {
+		const key = yield* validate(SubscriptionDeliveryKey, input, "delivery-key");
+		yield* requirePartition(key.subscription.partition, "delivery-partition");
+		return yield* readDelivery(key, "get delivery");
+	});
+	const pendingDeliveries = Effect.fn("SqliteSubscriptionStore.pendingDeliveries")(function* (nowMillis, after, limit) {
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, event_id FROM effect_agent_subscription_deliveries
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state NOT IN ('delivered','refused')
+        AND next_attempt_at_millis<=${nowMillis} AND delivery_key>${after} ORDER BY delivery_key LIMIT ${limit}
+    `, "pending deliveries");
+		const rowSchema = Schema.Struct({
+			owner_id: Schema.String,
+			subscription_id: Schema.String,
+			event_id: Schema.String
+		});
+		return yield* decodeRows(rowSchema, rows, "pending delivery keys").pipe(Effect.map((items) => items.map((item) => ({
+			subscription: {
+				partition,
+				ownerId: item.owner_id,
+				subscriptionId: item.subscription_id
+			},
+			eventId: item.event_id
+		}))));
+	});
+	const listDeliveries = Effect.fn("SqliteSubscriptionStore.listDeliveries")(function* (input, after, limit) {
+		const key = yield* requireKey(input, "list-deliveries-key");
+		const rows = yield* query(sql`
+      SELECT record_json FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+        AND owner_id=${key.ownerId} AND subscription_id=${key.subscriptionId} AND delivery_key>${after} ORDER BY delivery_key LIMIT ${limit}
+    `, "list deliveries");
+		const decoded = yield* decodeRows(JsonRow, rows, "list deliveries");
+		return yield* Effect.forEach(decoded, (row) => decode(SubscriptionDelivery, row.record_json, "list delivery"));
+	});
+	const changeDelivery = Effect.fn("SqliteSubscriptionStore.changeDelivery")(function* (inputKey, inputDeliveryId, inputChange) {
+		const key = yield* validate(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
+		const deliveryId = yield* validate(Digest, inputDeliveryId, "change-delivery-id");
+		const change = yield* validate(DeliveryChange, inputChange, "change-delivery-change");
+		yield* requirePartition(key.subscription.partition, "change-delivery-partition");
+		const result = yield* transact(Effect.gen(function* () {
+			const existing = yield* readDelivery(key, "change delivery");
+			const record = yield* readRegistration(key.subscription, "change delivery subscription");
+			if (existing === null || record === null) return yield* error("not-found", existing === null ? "delivery" : "subscription");
+			yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:before`);
+			const effectiveChange = change._tag === "Prepare" ? {
+				...change,
+				nowMillis: Math.max(change.nowMillis, yield* Clock.currentTimeMillis)
+			} : change;
+			const transition = applySubscriptionDeliveryChange(existing, record, deliveryId, effectiveChange);
+			if (Result.isFailure(transition)) return yield* transition.failure;
+			if (transition.success === existing) return {
+				value: existing,
+				changed: false
+			};
+			yield* writeDelivery(transition.success);
+			return {
+				value: transition.success,
+				changed: true
+			};
+		}));
+		if (result.changed) yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
+		return result.value;
+	});
+	const recovering = Effect.fn("SqliteSubscriptionStore.recovering")(function* (nowMillis, after, limit) {
+		const rows = yield* query(sql`
+      SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state='active'
+        AND recovery_at_millis IS NOT NULL AND recovery_at_millis<=${nowMillis} AND ordinal>${after}
+      ORDER BY ordinal LIMIT ${limit}
+    `, "recovering subscriptions");
+		const rowSchema = Schema.Struct({
+			owner_id: Schema.String,
+			subscription_id: Schema.String,
+			ordinal: Schema.Natural
+		});
+		return yield* decodeRows(rowSchema, rows, "recovering subscription keys").pipe(Effect.map((items) => items.map((item) => ({
+			key: {
+				partition,
+				ownerId: item.owner_id,
+				subscriptionId: item.subscription_id
+			},
+			ordinal: item.ordinal
+		}))));
+	});
+	const deferRecovery = Effect.fn("SqliteSubscriptionStore.deferRecovery")(function* (input, recovery) {
+		const key = yield* requireKey(input, "defer-recovery-key");
+		yield* transact(Effect.gen(function* () {
+			const record = yield* readRegistration(key, "defer recovery");
+			if (record === null) return yield* error("not-found", "subscription");
+			yield* failpoint.hit("subscription:defer-recovery:before");
+			yield* writeRegistration({
+				...record,
+				recovery: record.state === "active" ? recovery : null
+			});
+		}));
+		yield* failpoint.hit("subscription:defer-recovery:after");
+	});
+	const readScanCursors = Effect.gen(function* () {
+		const rows = yield* query(sql`
+      SELECT event_scan_cursor, delivery_scan_cursor, recovery_scan_cursor
+      FROM effect_agent_subscription_sequences
+      WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+    `, "read subscription scan cursors");
+		const decoded = yield* decodeRows(ScanRow, rows, "read subscription scan cursors");
+		if (decoded.length !== 1) return yield* corrupt("subscription scan cursors");
+		return {
+			events: decoded[0].event_scan_cursor,
+			deliveries: decoded[0].delivery_scan_cursor,
+			recovery: decoded[0].recovery_scan_cursor
+		};
+	});
+	const advanceScanCursors = Effect.fn("SqliteSubscriptionStore.advanceScanCursors")(function* (input) {
+		const cursors = yield* validate(SubscriptionScanCursors, input, "scan-cursors");
+		yield* transact(Effect.gen(function* () {
+			yield* failpoint.hit("subscription:advance-scan-cursors:before");
+			yield* query(sql`
+        UPDATE effect_agent_subscription_sequences
+        SET event_scan_cursor=${cursors.events}, delivery_scan_cursor=${cursors.deliveries}, recovery_scan_cursor=${cursors.recovery}
+        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
+      `, "advance subscription scan cursors");
+		}));
+		yield* failpoint.hit("subscription:advance-scan-cursors:after");
+	});
+	const indexedDeadline = query(sql`
+    SELECT MIN(deadline) AS deadline FROM (
+      SELECT next_attempt_at_millis AS deadline FROM effect_agent_subscription_events
+        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND routing_complete=0
+      UNION ALL SELECT next_attempt_at_millis FROM effect_agent_subscription_deliveries
+        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state NOT IN ('delivered','refused')
+      UNION ALL SELECT recovery_at_millis FROM effect_agent_subscriptions
+        WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND state='active' AND recovery_at_millis IS NOT NULL
+    )
+  `, "next subscription deadline").pipe(Effect.flatMap((rows) => decodeRows(Schema.Struct({ deadline: Schema.NullOr(Schema.Number) }), rows, "next subscription deadline")), Effect.flatMap((rows) => rows.length === 1 ? Effect.succeed(rows[0].deadline) : Effect.fail(corrupt("next subscription deadline"))));
+	const nextDeadline = Effect.gen(function* () {
+		const cursors = yield* readScanCursors;
+		if (cursors.events !== "" || cursors.deliveries !== "" || cursors.recovery !== 0) return 0;
+		return yield* indexedDeadline;
+	});
+	const prearm = Effect.fn("DoSubscriptionStore.prearm")(function* (deadlineAtMillis) {
+		yield* transactions.run((replace) => replaceAlarm(replace, deadlineAtMillis));
+		yield* failpoint.hit("subscription:prearm:after");
+	});
+	const reconcile = Effect.gen(function* () {
+		yield* transactions.run((replace) => Effect.gen(function* () {
+			yield* replaceAlarm(replace, yield* readIndexedDeadline());
+		}));
+		yield* failpoint.hit("subscription:reconcile:after");
+	});
+	return Context.make(SubscriptionStore, {
+		partition,
+		register,
+		get,
+		list,
+		cancel,
+		accept,
+		event,
+		pendingEvents,
+		candidates,
+		select,
+		catchUp,
+		deferEvent,
+		delivery,
+		pendingDeliveries,
+		listDeliveries,
+		changeDelivery,
+		recovering,
+		deferRecovery,
+		readScanCursors,
+		advanceScanCursors,
+		nextDeadline
+	}).pipe(Context.add(DoSubscriptionAlarmControl, {
+		prearm,
+		reconcile
+	}));
+});
+const doSubscriptionStoreLayer = (partition) => Layer.effectContext(makeSubscriptionStore(partition));
+//#endregion
 //#region src/port-protocol.ts
 /**
 * The cross-Durable-Object port protocol (plan §1.3, D-P6-3): Schema request/response/error
-* envelopes for the CLOSED route-capable subset of the session ports. One Conversation's
-* Durable Object executes another Conversation's request against its OWN local facets; the
+* envelopes for the CLOSED route-capable subset of the thread ports. One Thread's
+* Durable Object executes another Thread's request against its OWN local facets; the
 * envelopes here are the only values that cross the Object boundary, and they are
 * transport-agnostic — native Durable Object JS RPC is the shipped carrier, fetch-with-JSON
 * the documented fallback, and both move the same Schema-encoded JSON.
 *
 * The closed subset is exactly the set of operations the durable coordinator performs against
-* a FOREIGN Conversation (parent/child establishment, status checks, abort propagation,
-* child-settlement notification, and the child-conversation store operations used by
+* a FOREIGN Thread (parent/child establishment, status checks, abort propagation,
+* child-settlement notification, and the child-thread store operations used by
 * establishment, `verifySettledChild`, and result projection):
 *
 * - ledger: `admit`, `markReady`, `lookup`, `resolveAdmission`, `requestAbort`,
@@ -3595,18 +4262,18 @@ const scheduleStoreLayer = Layer.effectContext(makeServices);
 *
 * Failures cross the boundary as the `PortFailure` union and re-decode on the caller side to
 * the SAME tagged error types the local facet would have produced, so routed calls keep
-* error-tag fidelity. `cause` chains inside `LedgerError`/`ConversationStoreError` travel as
+* error-tag fidelity. `cause` chains inside `LedgerError`/`ThreadStoreError` travel as
 * Schema defects and do not claim instance fidelity across Objects (plan §2.8).
 */
 /** Ceiling for protocol diagnostic strings; matches `AdmissionIndeterminate.reason`. */
 const MAX_PORT_DIAGNOSTIC_LENGTH = 4096;
 const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_PORT_DIAGNOSTIC_LENGTH));
 /** Truncate a diagnostic string to the protocol's bounded diagnostic length. */
-const boundPortDiagnostic = (value) => value.length > 4096 ? `${value.slice(0, MAX_PORT_DIAGNOSTIC_LENGTH - 3)}...` : value;
+const boundPortDiagnostic = (value) => value.length > 4096 ? `${value.slice(0, 4093)}...` : value;
 /**
 * The envelope itself could not be honored: the receiving Object could not decode the
 * request, or a response could not be encoded/decoded. It never carries port semantics —
-* callers fold it into the operation's base error (`LedgerError`/`ConversationStoreError`),
+* callers fold it into the operation's base error (`LedgerError`/`ThreadStoreError`),
 * except `resolveAdmission`, which folds it into `AdmissionIndeterminate` because a
 * non-answer is never proof of absence (SUB-031).
 */
@@ -3623,16 +4290,16 @@ var LedgerResolveAdmissionCall = class extends Schema.TaggedClass("@effect-agent
 var LedgerRequestAbortCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRequestAbortCall")("LedgerRequestAbort", { request: AbortCommand }) {};
 /** Routed `SubmissionLedger.recordChildSettled` — the child→parent durable notification. */
 var LedgerRecordChildSettledCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/LedgerRecordChildSettledCall")("LedgerRecordChildSettled", { request: ChildSettledNotification }) {};
-/** Routed `ConversationStore.materialize` against the owning Object. */
-var StoreMaterializeCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeCall")("StoreMaterialize", { request: ConversationMaterialization }) {};
-/** Routed `ConversationStore.append` against the owning Object. */
+/** Routed `ThreadStore.materialize` against the owning Object. */
+var StoreMaterializeCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreMaterializeCall")("StoreMaterialize", { request: ThreadMaterialization }) {};
+/** Routed `ThreadStore.append` against the owning Object. */
 var StoreAppendCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendCall")("StoreAppend", { request: FencedAppendRequest }) {};
-/** Routed one-page `ConversationStore.read`; the page bound is the request's own `limit`. */
-var StoreReadPageCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageCall")("StoreReadPage", { request: ConversationRead }) {};
-/** Routed `ConversationStore.inspectTail` against the owning Object. */
-var StoreInspectTailCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailCall")("StoreInspectTail", { request: ConversationTailRequest }) {};
-/** Routed `ConversationStore.export` against the owning Object. */
-var StoreExportCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportCall")("StoreExport", { request: ConversationExportRequest }) {};
+/** Routed one-page `ThreadStore.read`; the page bound is the request's own `limit`. */
+var StoreReadPageCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageCall")("StoreReadPage", { request: ThreadRead }) {};
+/** Routed `ThreadStore.inspectTail` against the owning Object. */
+var StoreInspectTailCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailCall")("StoreInspectTail", { request: ThreadTailRequest }) {};
+/** Routed `ThreadStore.export` against the owning Object. */
+var StoreExportCall = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportCall")("StoreExport", { request: ThreadExportRequest }) {};
 /** Every request that may cross a Durable Object boundary — the CLOSED route-capable subset. */
 const PortRequest = Schema.Union([
 	LedgerAdmitCall,
@@ -3658,8 +4325,8 @@ var StoreMaterializeResult = class extends Schema.TaggedClass("@effect-agent/sto
 var StoreAppendResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreAppendResult")("StoreAppendResult", { result: AppendResult }) {};
 /** One page of canonical records, bounded by the request's `limit` (≤ 1,024). */
 var StoreReadPageResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreReadPageResult")("StoreReadPageResult", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
-var StoreInspectTailResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailResult")("StoreInspectTailResult", { tail: ConversationTail }) {};
-var StoreExportResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportResult")("StoreExportResult", { export: ConversationExport }) {};
+var StoreInspectTailResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreInspectTailResult")("StoreInspectTailResult", { tail: ThreadTail }) {};
+var StoreExportResult = class extends Schema.TaggedClass("@effect-agent/storage-cloudflare/StoreExportResult")("StoreExportResult", { export: ThreadExport }) {};
 /** Every successful routed result. Callers narrow by the tag their request implies. */
 const PortResult = Schema.Union([
 	LedgerAdmitResult,
@@ -3677,15 +4344,15 @@ const PortResult = Schema.Union([
 /**
 * Every typed failure a route-capable operation can produce on its owning Object, plus the
 * protocol's own `PortProtocolError`. Members re-decode to the SAME tagged classes the
-* session ports declare, so a routed caller observes identical error tags and fields.
+* thread ports declare, so a routed caller observes identical error tags and fields.
 */
 const PortFailure = Schema.Union([
 	AdmissionConflict,
 	SettlementConflict,
 	JoinedToHost,
 	LedgerError,
-	ConversationStoreError,
-	ConversationNotMaterialized,
+	ThreadStoreError,
+	ThreadNotMaterialized,
 	AppendConflict,
 	FenceRejected,
 	PortProtocolError
@@ -3702,8 +4369,8 @@ const encodePortResponse = Schema.encodeEffect(PortResponse);
 const decodePortResponse = Schema.decodeUnknownEffect(PortResponse);
 //#endregion
 //#region src/routing.ts
-const ConversationIdSchema = ConversationMaterialization.fields.conversationId;
-const decodeConversationId = Schema.decodeUnknownEffect(ConversationIdSchema);
+const ThreadIdSchema = ThreadMaterialization.fields.threadId;
+const decodeThreadId = Schema.decodeUnknownEffect(ThreadIdSchema);
 /**
 * The ledger row bound routable Submission identities must respect (mirrors the local
 * facet's `MAX_IDENTIFIER_LENGTH`; the minting side already refuses longer identities typed
@@ -3714,7 +4381,7 @@ const MAX_ROUTABLE_SUBMISSION_ID_LENGTH = 1024;
 const UUID_HEAD_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 /**
 * A transport could not deliver a port request to (or an answer from) the owning
-* Conversation's Durable Object. `retryable` carries the platform's own stub signal when one
+* Thread's Durable Object. `retryable` carries the platform's own stub signal when one
 * exists. This error never crosses the wire — it is the CALLER-side evidence that the
 * authority was unreachable, which is exactly the case `AdmissionIndeterminate` was
 * specified for (SUB-031).
@@ -3757,24 +4424,24 @@ const portTransportFailure = (target, cause) => {
 };
 /**
 * Delivery of Schema-encoded port envelopes to the Durable Object that owns a FOREIGN
-* Conversation (plan §1.3, D-P6-3). The shipped implementation (platform-cloudflare, WP3)
+* Thread (plan §1.3, D-P6-3). The shipped implementation (platform-cloudflare, WP3)
 * calls the owner's `portCall` over native Durable Object JS RPC via
-* `namespace.idFromName(conversationId)`; the protocol is transport-agnostic and any carrier
+* `namespace.idFromName(threadId)`; the protocol is transport-agnostic and any carrier
 * that moves the encoded envelopes verbatim satisfies this service. Implementations MUST
 * surface every delivery problem as `PortTransportError` and must never fabricate an answer.
 */
-var ConversationPortTransport = class extends Context.Service()("@effect-agent/storage-cloudflare/ConversationPortTransport") {};
+var ThreadPortTransport = class extends Context.Service()("@effect-agent/storage-cloudflare/ThreadPortTransport") {};
 const LOCAL = { _tag: "local" };
 /**
-* Parse a DC-minted routable Submission identity — `{uuidv7}:{conversationId}`, split at the
-* FIRST `:` because the Conversation tail may itself contain colons (D-P6-5). This adapter
+* Parse a DC-minted routable Submission identity — `{uuidv7}:{threadId}`, split at the
+* FIRST `:` because the Thread tail may itself contain colons (D-P6-5). This adapter
 * minted the format at admission and is the ONLY component that parses it; identities that do
 * not carry the minted shape (no separator, non-UUID head, empty tail) fall back to the local
 * facet, which is the only authority this Object can consult without inventing an owner.
 * Identities beyond the ledger's 1,024-character row bound fail typed: the minting side
 * refused them at admission, so they cannot name any stored row anywhere.
 */
-const routableSubmissionTarget = (localConversationId) => Effect.fn("DoPortRouting.routableSubmissionTarget")(function* (operation, submissionId) {
+const routableSubmissionTarget = (localThreadId) => Effect.fn("DoPortRouting.routableSubmissionTarget")(function* (operation, submissionId) {
 	if (submissionId.length > MAX_ROUTABLE_SUBMISSION_ID_LENGTH) return yield* LedgerError.make({
 		operation,
 		message: `A Submission identity of ${submissionId.length} characters exceeds the ${MAX_ROUTABLE_SUBMISSION_ID_LENGTH}-character routable identity bound; admission refuses such identities, so it cannot name any stored row.`
@@ -3783,16 +4450,16 @@ const routableSubmissionTarget = (localConversationId) => Effect.fn("DoPortRouti
 	if (separator === -1) return LOCAL;
 	if (!UUID_HEAD_PATTERN.test(submissionId.slice(0, separator))) return LOCAL;
 	const tail = submissionId.slice(separator + 1);
-	if (tail === localConversationId) return LOCAL;
-	return yield* decodeConversationId(tail).pipe(Effect.map((conversationId) => ({
+	if (tail === localThreadId) return LOCAL;
+	return yield* decodeThreadId(tail).pipe(Effect.map((threadId) => ({
 		_tag: "foreign",
-		conversationId
+		threadId
 	})), Effect.orElseSucceed(() => LOCAL));
 });
 const NoAdditionalPortFailure = Schema.Never;
 const AbortPortFailure = Schema.Union([SettlementConflict, JoinedToHost]);
 const AppendPortFailure = Schema.Union([
-	ConversationNotMaterialized,
+	ThreadNotMaterialized,
 	AppendConflict,
 	FenceRejected
 ]);
@@ -3800,26 +4467,27 @@ const AppendPortFailure = Schema.Union([
 * The fail-fast refusal for any foreign operation OUTSIDE the closed route-capable subset
 * (plan §1.3): honesty over accidental distribution.
 */
-const crossConversationLedgerError = (operation, target) => LedgerError.make({
+const crossThreadLedgerError = (operation, target) => LedgerError.make({
 	operation,
-	message: `${operation} addressed to foreign Conversation ${target} is not route-capable; the closed cross-Object subset is admit, markReady, lookup, resolveAdmission, requestAbort, and recordChildSettled. Every other ledger operation is lane-local by construction and must execute inside the owning Conversation's Durable Object.`
+	message: `${operation} addressed to foreign Thread ${target} is not route-capable; the closed cross-Object subset is admit, markReady, lookup, resolveAdmission, requestAbort, and recordChildSettled. Every other ledger operation is lane-local by construction and must execute inside the owning Thread's Durable Object.`
 });
-const crossConversationStoreError = (operation, target) => ConversationStoreError.make({
+const crossThreadStoreError = (operation, target) => ThreadStoreError.make({
 	operation,
-	message: `${operation} addressed to foreign Conversation ${target} is not route-capable; the closed cross-Object subset is materialize, append, read (paged), inspectTail, and export. Observation and checkpoints are lane-local by construction and must execute inside the owning Conversation's Durable Object.`
+	message: `${operation} addressed to foreign Thread ${target} is not route-capable; the closed cross-Object subset is materialize, append, read (paged), inspectTail, and export. Observation and checkpoints are lane-local by construction and must execute inside the owning Thread's Durable Object.`
 });
 const makeTransportCall = (transport) => Effect.fn("DoPortRouting.transportCall")(function* (target, call) {
 	const encoded = yield* encodePortRequest(call).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be encoded: ${error.message}`) })));
-	return yield* decodePortResponse(yield* transport.call(target, encoded)).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port response could not be decoded: ${error.message}`) })));
+	const raw = yield* transport.call(target, encoded);
+	return yield* decodePortResponse(raw).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port response could not be decoded: ${error.message}`) })));
 });
 const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServices")(function* (options) {
 	const local = yield* SubmissionLedger;
-	const transport = yield* ConversationPortTransport;
+	const transport = yield* ThreadPortTransport;
 	const transportCall = makeTransportCall(transport);
-	const submissionTarget = routableSubmissionTarget(options.localConversationId);
+	const submissionTarget = routableSubmissionTarget(options.localThreadId);
 	const routeFailure = (operation, target) => (error) => LedgerError.make({
 		operation,
-		message: boundPortDiagnostic(`Routed ${operation} to the Conversation Object owning ${target} failed: ${error.message}`),
+		message: boundPortDiagnostic(`Routed ${operation} to the Thread Object owning ${target} failed: ${error.message}`),
 		cause: error
 	});
 	/**
@@ -3838,14 +4506,14 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 				if (failure._tag === "LedgerError") return Effect.fail(failure);
 				return Effect.fail(LedgerError.make({
 					operation,
-					message: boundPortDiagnostic(`The Conversation Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
+					message: boundPortDiagnostic(`The Thread Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
 					cause: failure
 				}));
 			}
 			const result = response.result;
 			if (!isExpectedResult(result)) return Effect.fail(LedgerError.make({
 				operation,
-				message: `The Conversation Object owning ${target} answered ${operation} with the mismatched result ${result._tag}.`
+				message: `The Thread Object owning ${target} answered ${operation} with the mismatched result ${result._tag}.`
 			}));
 			return Effect.succeed(result);
 		}), Effect.withSpan("DoPortRouting.foreignLedgerCall", { attributes: {
@@ -3864,13 +4532,13 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 	const resolveForeignAdmission = (target, request) => transportCall(target, LedgerResolveAdmissionCall.make({ request })).pipe(Effect.flatMap((response) => {
 		if (response._tag === "PortFailed") {
 			if (response.failure._tag === "LedgerError") return Effect.fail(response.failure);
-			return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} answered resolveAdmission with the out-of-contract failure ${response.failure._tag}: ${response.failure.message}`) }));
+			return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Thread Object owning ${target} answered resolveAdmission with the out-of-contract failure ${response.failure._tag}: ${response.failure.message}`) }));
 		}
-		if (response.result._tag !== "LedgerResolveAdmissionResult") return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} answered resolveAdmission with the mismatched result ${response.result._tag}.`) }));
+		if (response.result._tag !== "LedgerResolveAdmissionResult") return Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Thread Object owning ${target} answered resolveAdmission with the mismatched result ${response.result._tag}.`) }));
 		return Effect.succeed(response.result.resolution);
 	}), Effect.catchTags({
-		PortTransportError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Conversation Object owning ${target} is unreachable: ${error.message}`) })),
-		PortProtocolError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The answer of the Conversation Object owning ${target} could not be understood: ${error.message}`) }))
+		PortTransportError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The Thread Object owning ${target} is unreachable: ${error.message}`) })),
+		PortProtocolError: (error) => Effect.succeed(AdmissionIndeterminate.make({ reason: boundPortDiagnostic(`The answer of the Thread Object owning ${target} could not be understood: ${error.message}`) }))
 	}), Effect.withSpan("DoPortRouting.resolveForeignAdmission", { attributes: { target } }));
 	const foreignLookupById = (operation, target, submissionId) => foreignLedgerCall(operation, target, LedgerLookupCall.make({ request: SubmissionLookupById.make({ submissionId }) }), LedgerLookupResult, NoAdditionalPortFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission)));
 	/**
@@ -3889,7 +4557,7 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 			if (childSubmissionId === void 0 || attachments.has(childSubmissionId)) continue;
 			const target = yield* submissionTarget(operation, childSubmissionId);
 			if (target._tag !== "foreign") continue;
-			const child = yield* foreignLookupById(operation, target.conversationId, childSubmissionId);
+			const child = yield* foreignLookupById(operation, target.threadId, childSubmissionId);
 			if (Option.isNone(child)) continue;
 			attachments.set(childSubmissionId, ChildAttachmentSnapshot.make({
 				toolCallId: reservation.parentToolCallId,
@@ -3913,44 +4581,45 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 	});
 	const routed = SubmissionLedger.of({
 		capabilities: local.capabilities,
-		admit: (request) => request.conversationId === options.localConversationId ? local.admit(request) : foreignLedgerCall("ledger admit", request.conversationId, LedgerAdmitCall.make({ request }), LedgerAdmitResult, AdmissionConflict).pipe(Effect.map((reply) => reply.result)),
-		markReady: (request) => submissionTarget("ledger mark ready", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markReady(request) : foreignLedgerCall("ledger mark ready", target.conversationId, LedgerMarkReadyCall.make({ request }), LedgerMarkReadyResult, NoAdditionalPortFailure).pipe(Effect.asVoid))),
-		lookup: (request) => request._tag === "SubmissionLookupById" ? submissionTarget("ledger lookup", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.lookup(request) : foreignLookupById("ledger lookup", target.conversationId, request.submissionId))) : request.conversationId === options.localConversationId ? local.lookup(request) : foreignLedgerCall("ledger lookup", request.conversationId, LedgerLookupCall.make({ request }), LedgerLookupResult, NoAdditionalPortFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission))),
-		resolveAdmission: (request) => request.conversationId === options.localConversationId ? local.resolveAdmission(request) : resolveForeignAdmission(request.conversationId, request),
-		requestAbort: (request) => submissionTarget("ledger request abort", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.requestAbort(request) : foreignLedgerCall("ledger request abort", target.conversationId, LedgerRequestAbortCall.make({ request }), LedgerRequestAbortResult, AbortPortFailure).pipe(Effect.map((reply) => reply.intent)))),
-		recordChildSettled: (request) => submissionTarget("ledger record child settled", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordChildSettled(request) : foreignLedgerCall("ledger record child settled", target.conversationId, LedgerRecordChildSettledCall.make({ request }), LedgerRecordChildSettledResult, NoAdditionalPortFailure).pipe(Effect.map((reply) => reply.outcome)))),
-		claim: (request) => request.conversationId === options.localConversationId ? local.claim(request) : Effect.fail(crossConversationLedgerError("ledger claim", request.conversationId)),
-		claimJoining: (request) => request.conversationId === options.localConversationId ? local.claimJoining(request) : Effect.fail(crossConversationLedgerError("ledger claim joining", request.conversationId)),
-		renewOwnership: (request) => submissionTarget("ledger renew ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.renewOwnership(request) : Effect.fail(crossConversationLedgerError("ledger renew ownership", target.conversationId)))),
-		releaseOwnership: (request) => submissionTarget("ledger release ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.releaseOwnership(request) : Effect.fail(crossConversationLedgerError("ledger release ownership", target.conversationId)))),
-		markInputApplied: (request) => submissionTarget("ledger mark input applied", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markInputApplied(request) : Effect.fail(crossConversationLedgerError("ledger mark input applied", target.conversationId)))),
-		reserveSettlement: (request) => submissionTarget("ledger reserve settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveSettlement(request) : Effect.fail(crossConversationLedgerError("ledger reserve settlement", target.conversationId)))),
-		finalizeSettlement: (request) => submissionTarget("ledger finalize settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.finalizeSettlement(request) : Effect.fail(crossConversationLedgerError("ledger finalize settlement", target.conversationId)))),
-		markJoined: (request) => submissionTarget("ledger mark joined", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markJoined(request) : Effect.fail(crossConversationLedgerError("ledger mark joined", target.conversationId)))),
-		revertJoining: (request) => submissionTarget("ledger revert joining", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.revertJoining(request) : Effect.fail(crossConversationLedgerError("ledger revert joining", target.conversationId)))),
-		suspend: (request) => submissionTarget("ledger suspend", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.suspend(request) : Effect.fail(crossConversationLedgerError("ledger suspend", target.conversationId)))),
-		recordApprovalDecision: (command) => submissionTarget("ledger record approval decision", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordApprovalDecision(command) : Effect.fail(crossConversationLedgerError("ledger record approval decision", target.conversationId)))),
-		markUnknown: (request) => submissionTarget("ledger mark unknown", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markUnknown(request) : Effect.fail(crossConversationLedgerError("ledger mark unknown", target.conversationId)))),
-		recordUnknownResolution: (command) => submissionTarget("ledger record unknown resolution", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordUnknownResolution(command) : Effect.fail(crossConversationLedgerError("ledger record unknown resolution", target.conversationId)))),
-		reserveChildBudget: (request) => submissionTarget("ledger reserve child budget", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveChildBudget(request) : Effect.fail(crossConversationLedgerError("ledger reserve child budget", target.conversationId)))),
+		admit: (request) => request.threadId === options.localThreadId ? local.admit(request) : foreignLedgerCall("ledger admit", request.threadId, LedgerAdmitCall.make({ request }), LedgerAdmitResult, AdmissionConflict).pipe(Effect.map((reply) => reply.result)),
+		markReady: (request) => submissionTarget("ledger mark ready", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markReady(request) : foreignLedgerCall("ledger mark ready", target.threadId, LedgerMarkReadyCall.make({ request }), LedgerMarkReadyResult, NoAdditionalPortFailure).pipe(Effect.asVoid))),
+		lookup: (request) => request._tag === "SubmissionLookupById" ? submissionTarget("ledger lookup", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.lookup(request) : foreignLookupById("ledger lookup", target.threadId, request.submissionId))) : request.threadId === options.localThreadId ? local.lookup(request) : foreignLedgerCall("ledger lookup", request.threadId, LedgerLookupCall.make({ request }), LedgerLookupResult, NoAdditionalPortFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission))),
+		resolveAdmission: (request) => request.threadId === options.localThreadId ? local.resolveAdmission(request) : resolveForeignAdmission(request.threadId, request),
+		requestAbort: (request) => submissionTarget("ledger request abort", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.requestAbort(request) : foreignLedgerCall("ledger request abort", target.threadId, LedgerRequestAbortCall.make({ request }), LedgerRequestAbortResult, AbortPortFailure).pipe(Effect.map((reply) => reply.intent)))),
+		recordChildSettled: (request) => submissionTarget("ledger record child settled", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordChildSettled(request) : foreignLedgerCall("ledger record child settled", target.threadId, LedgerRecordChildSettledCall.make({ request }), LedgerRecordChildSettledResult, NoAdditionalPortFailure).pipe(Effect.map((reply) => reply.outcome)))),
+		claim: (request) => request.threadId === options.localThreadId ? local.claim(request) : Effect.fail(crossThreadLedgerError("ledger claim", request.threadId)),
+		claimJoining: (request) => request.threadId === options.localThreadId ? local.claimJoining(request) : Effect.fail(crossThreadLedgerError("ledger claim joining", request.threadId)),
+		renewOwnership: (request) => submissionTarget("ledger renew ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.renewOwnership(request) : Effect.fail(crossThreadLedgerError("ledger renew ownership", target.threadId)))),
+		releaseOwnership: (request) => submissionTarget("ledger release ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.releaseOwnership(request) : Effect.fail(crossThreadLedgerError("ledger release ownership", target.threadId)))),
+		markInputApplied: (request) => submissionTarget("ledger mark input applied", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markInputApplied(request) : Effect.fail(crossThreadLedgerError("ledger mark input applied", target.threadId)))),
+		reserveSettlement: (request) => submissionTarget("ledger reserve settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveSettlement(request) : Effect.fail(crossThreadLedgerError("ledger reserve settlement", target.threadId)))),
+		finalizeSettlement: (request) => submissionTarget("ledger finalize settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.finalizeSettlement(request) : Effect.fail(crossThreadLedgerError("ledger finalize settlement", target.threadId)))),
+		markJoined: (request) => submissionTarget("ledger mark joined", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markJoined(request) : Effect.fail(crossThreadLedgerError("ledger mark joined", target.threadId)))),
+		revertJoining: (request) => submissionTarget("ledger revert joining", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.revertJoining(request) : Effect.fail(crossThreadLedgerError("ledger revert joining", target.threadId)))),
+		suspend: (request) => submissionTarget("ledger suspend", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.suspend(request) : Effect.fail(crossThreadLedgerError("ledger suspend", target.threadId)))),
+		recordApprovalDecision: (command) => submissionTarget("ledger record approval decision", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordApprovalDecision(command) : Effect.fail(crossThreadLedgerError("ledger record approval decision", target.threadId)))),
+		markUnknown: (request) => submissionTarget("ledger mark unknown", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markUnknown(request) : Effect.fail(crossThreadLedgerError("ledger mark unknown", target.threadId)))),
+		recordUnknownResolution: (command) => submissionTarget("ledger record unknown resolution", command.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordUnknownResolution(command) : Effect.fail(crossThreadLedgerError("ledger record unknown resolution", target.threadId)))),
+		reserveChildBudget: (request) => submissionTarget("ledger reserve child budget", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveChildBudget(request) : Effect.fail(crossThreadLedgerError("ledger reserve child budget", target.threadId)))),
 		attachChildToReservation: local.attachChildToReservation,
 		beginChildBudgetRelease: local.beginChildBudgetRelease,
 		releaseChildBudget: local.releaseChildBudget,
 		scanNonterminal: local.scanNonterminal,
-		loadRecoverySnapshot: (request) => submissionTarget("ledger load recovery snapshot", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.loadRecoverySnapshot(request).pipe(Effect.flatMap(enrichChildAttachments)) : Effect.fail(crossConversationLedgerError("ledger load recovery snapshot", target.conversationId))))
+		loadRecoverySnapshot: (request) => submissionTarget("ledger load recovery snapshot", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.loadRecoverySnapshot(request).pipe(Effect.flatMap(enrichChildAttachments)) : Effect.fail(crossThreadLedgerError("ledger load recovery snapshot", target.threadId))))
 	});
 	return Context.make(SubmissionLedger, routed);
 });
 const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices")(function* (options) {
-	const local = yield* ConversationStore;
-	const transport = yield* ConversationPortTransport;
+	const local = yield* ThreadStore;
+	const checkpoints = local.checkpoints;
+	const transport = yield* ThreadPortTransport;
 	const transportCall = makeTransportCall(transport);
-	const routeFailure = (operation, target) => (error) => ConversationStoreError.make({
+	const routeFailure = (operation, target) => (error) => ThreadStoreError.make({
 		operation,
-		message: boundPortDiagnostic(`Routed ${operation} to the Conversation Object owning ${target} failed: ${error.message}`),
+		message: boundPortDiagnostic(`Routed ${operation} to the Thread Object owning ${target} failed: ${error.message}`),
 		cause: error
 	});
-	/** The store twin of `foreignLedgerCall` with `ConversationStoreError` as the base error. */
+	/** The store twin of `foreignLedgerCall` with `ThreadStoreError` as the base error. */
 	const foreignStoreCall = (operation, target, call, resultSchema, failureSchema) => {
 		const isExpectedResult = Schema.is(resultSchema);
 		const isExpectedFailure = Schema.is(failureSchema);
@@ -3958,17 +4627,17 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
 			if (response._tag === "PortFailed") {
 				const failure = response.failure;
 				if (isExpectedFailure(failure)) return Effect.fail(failure);
-				if (failure._tag === "ConversationStoreError") return Effect.fail(failure);
-				return Effect.fail(ConversationStoreError.make({
+				if (failure._tag === "ThreadStoreError") return Effect.fail(failure);
+				return Effect.fail(ThreadStoreError.make({
 					operation,
-					message: boundPortDiagnostic(`The Conversation Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
+					message: boundPortDiagnostic(`The Thread Object owning ${target} answered ${operation} with the out-of-contract failure ${failure._tag}: ${failure.message}`),
 					cause: failure
 				}));
 			}
 			const result = response.result;
-			if (!isExpectedResult(result)) return Effect.fail(ConversationStoreError.make({
+			if (!isExpectedResult(result)) return Effect.fail(ThreadStoreError.make({
 				operation,
-				message: `The Conversation Object owning ${target} answered ${operation} with the mismatched result ${result._tag}.`
+				message: `The Thread Object owning ${target} answered ${operation} with the mismatched result ${result._tag}.`
 			}));
 			return Effect.succeed(result);
 		}), Effect.withSpan("DoPortRouting.foreignStoreCall", { attributes: {
@@ -3976,39 +4645,41 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
 			target
 		} }));
 	};
-	const routed = ConversationStore.of({
-		materialize: (request) => request.conversationId === options.localConversationId ? local.materialize(request) : foreignStoreCall("conversation materialize", request.conversationId, StoreMaterializeCall.make({ request }), StoreMaterializeResult, FenceRejected).pipe(Effect.asVoid),
-		append: (request) => request.conversationId === options.localConversationId ? local.append(request) : foreignStoreCall("conversation append", request.conversationId, StoreAppendCall.make({ request }), StoreAppendResult, AppendPortFailure).pipe(Effect.map((reply) => reply.result)),
-		read: (request) => request.conversationId === options.localConversationId ? local.read(request) : Stream.unwrap(foreignStoreCall("conversation read", request.conversationId, StoreReadPageCall.make({ request }), StoreReadPageResult, ConversationNotMaterialized).pipe(Effect.map((reply) => Stream.fromIterable(reply.records)))),
-		inspectTail: (request) => request.conversationId === options.localConversationId ? local.inspectTail(request) : foreignStoreCall("conversation inspect tail", request.conversationId, StoreInspectTailCall.make({ request }), StoreInspectTailResult, ConversationNotMaterialized).pipe(Effect.map((reply) => reply.tail)),
-		export: (request) => request.conversationId === options.localConversationId ? local.export(request) : foreignStoreCall("conversation export", request.conversationId, StoreExportCall.make({ request }), StoreExportResult, ConversationNotMaterialized).pipe(Effect.map((reply) => reply.export)),
-		observe: (request) => request.conversationId === options.localConversationId ? local.observe(request) : Stream.unwrap(Effect.fail(crossConversationStoreError("conversation observe", request.conversationId))),
-		saveCheckpoint: (request) => request.checkpoint.conversationId === options.localConversationId ? local.saveCheckpoint(request) : Effect.fail(crossConversationStoreError("conversation save checkpoint", request.checkpoint.conversationId)),
-		loadCheckpoint: (request) => request.conversationId === options.localConversationId ? local.loadCheckpoint(request) : Effect.fail(crossConversationStoreError("conversation load checkpoint", request.conversationId))
-	});
-	return Context.make(ConversationStore, routed);
+	const routed = ThreadStore.of({
+		materialize: (request) => request.threadId === options.localThreadId ? local.materialize(request) : foreignStoreCall("thread materialize", request.threadId, StoreMaterializeCall.make({ request }), StoreMaterializeResult, FenceRejected).pipe(Effect.asVoid),
+		append: (request) => request.threadId === options.localThreadId ? local.append(request) : foreignStoreCall("thread append", request.threadId, StoreAppendCall.make({ request }), StoreAppendResult, AppendPortFailure).pipe(Effect.map((reply) => reply.result)),
+		read: (request) => request.threadId === options.localThreadId ? local.read(request) : Stream.unwrap(foreignStoreCall("thread read", request.threadId, StoreReadPageCall.make({ request }), StoreReadPageResult, ThreadNotMaterialized).pipe(Effect.map((reply) => Stream.fromIterable(reply.records)))),
+		inspectTail: (request) => request.threadId === options.localThreadId ? local.inspectTail(request) : foreignStoreCall("thread inspect tail", request.threadId, StoreInspectTailCall.make({ request }), StoreInspectTailResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.tail)),
+		export: (request) => request.threadId === options.localThreadId ? local.export(request) : foreignStoreCall("thread export", request.threadId, StoreExportCall.make({ request }), StoreExportResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.export)),
+		observe: (request) => request.threadId === options.localThreadId ? local.observe(request) : Stream.unwrap(Effect.fail(crossThreadStoreError("thread observe", request.threadId))),
+		...checkpoints === void 0 ? {} : { checkpoints: {
+			save: (request) => request.checkpoint.threadId === options.localThreadId ? checkpoints.save(request) : Effect.fail(crossThreadStoreError("thread save checkpoint", request.checkpoint.threadId)),
+			load: (request) => request.threadId === options.localThreadId ? checkpoints.load(request) : Effect.fail(crossThreadStoreError("thread load checkpoint", request.threadId))
+		} }
+	});
+	return Context.make(ThreadStore, routed);
 });
 /**
 * Routing decorator over the LOCAL `SubmissionLedger` facet (plan §1.3): a request addressing
-* this Object's Conversation executes locally; a route-capable request addressing another
-* Conversation is Schema-encoded onto the `ConversationPortTransport` and executed by the
+* this Object's Thread executes locally; a route-capable request addressing another
+* Thread is Schema-encoded onto the `ThreadPortTransport` and executed by the
 * owning Object's local facet; any other foreign request fails fast typed. Provide the WP1
 * local facet (`submissionLedgerLayer`/`ledgerLayer`) and a transport to close it.
 */
 const routedSubmissionLedgerLayer = (options) => Layer.effectContext(makeRoutedLedgerServices(options));
 /**
-* Routing decorator over the LOCAL `ConversationStore` facet (plan §1.3): this-conversation
+* Routing decorator over the LOCAL `ThreadStore` facet (plan §1.3): this-thread
 * requests execute locally; foreign materialize/append/read/inspectTail/export travel the
 * transport; foreign observation and checkpoints fail fast typed.
 */
-const routedConversationStoreLayer = (options) => Layer.effectContext(makeRoutedStoreServices(options));
+const routedThreadStoreLayer = (options) => Layer.effectContext(makeRoutedStoreServices(options));
 /** Fold one port operation's typed failures into the uniform response envelope. */
 const capture = (effect) => effect.pipe(Effect.map((result) => PortSucceeded.make({ result })), Effect.catch((failure) => Effect.succeed(PortFailed.make({ failure }))));
 /**
 * Execute one decoded port request against THIS Object's LOCAL facets — the owner-side half
 * of the routed ports (plan §1.3). Callers must provide the WP1 local facets, never the
 * routed decorators: the routing layer already established that this Object owns the
-* addressed Conversation, and re-routing here could bounce a request between Objects.
+* addressed Thread, and re-routing here could bounce a request between Objects.
 * Failures never escape — every typed port failure becomes a `PortFailed` envelope that
 * re-decodes on the caller side.
 */
@@ -4039,24 +4710,24 @@ const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(functio
 			return yield* capture(ledger.recordChildSettled(request.request).pipe(Effect.map((outcome) => LedgerRecordChildSettledResult.make({ outcome }))));
 		}
 		case "StoreMaterialize": {
-			const store = yield* ConversationStore;
+			const store = yield* ThreadStore;
 			return yield* capture(store.materialize(request.request).pipe(Effect.map(() => StoreMaterializeResult.make({}))));
 		}
 		case "StoreAppend": {
-			const store = yield* ConversationStore;
+			const store = yield* ThreadStore;
 			return yield* capture(store.append(request.request).pipe(Effect.map((result) => StoreAppendResult.make({ result }))));
 		}
 		case "StoreReadPage": {
-			const store = yield* ConversationStore;
+			const store = yield* ThreadStore;
 			return yield* capture(store.read(request.request).pipe(Stream.runCollect, Effect.map((records) => StoreReadPageResult.make({ records: [...records] }))));
 		}
 		case "StoreInspectTail": {
-			const store = yield* ConversationStore;
+			const store = yield* ThreadStore;
 			return yield* capture(store.inspectTail(request.request).pipe(Effect.map((tail) => StoreInspectTailResult.make({ tail }))));
 		}
 		case "StoreExport": {
-			const store = yield* ConversationStore;
-			return yield* capture(store.export(request.request).pipe(Effect.map((conversationExport) => StoreExportResult.make({ export: conversationExport }))));
+			const store = yield* ThreadStore;
+			return yield* capture(store.export(request.request).pipe(Effect.map((threadExport) => StoreExportResult.make({ export: threadExport }))));
 		}
 	}
 });
@@ -4080,9 +4751,10 @@ const encodedProtocolFailure = (message) => ({
 * transport never has to interpret exceptions as protocol answers.
 */
 const handleEncodedPortRequest = Effect.fn("DoPortRouting.handleEncodedPortRequest")(function* (encoded) {
-	return yield* encodePortResponse(yield* decodePortRequest(encoded).pipe(Effect.flatMap(executePortRequest), Effect.catch((error) => Effect.succeed(PortFailed.make({ failure: PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`) }) }))))).pipe(Effect.catch((error) => Effect.succeed(encodedProtocolFailure(`The port response could not be encoded: ${error.message}`))));
+	const response = yield* decodePortRequest(encoded).pipe(Effect.flatMap(executePortRequest), Effect.catch((error) => Effect.succeed(PortFailed.make({ failure: PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`) }) }))));
+	return yield* encodePortResponse(response).pipe(Effect.catch((error) => Effect.succeed(encodedProtocolFailure(`The port response could not be encoded: ${error.message}`))));
 });
 //#endregion
-export { ConversationPortTransport, CurrentDoStorageVersion, DEFAULT_MAX_STORED_VALUE_BYTES, DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoLedgerError, DoScheduleAlarmControl, DoScheduleTransaction, DoStorageCompatibilityError, DoStorageConfig, DoStorageConfigValue, DoStorageCorruptionError, DoStorageError, DoStorageFailpoint, DoStorageFailpointError, DoStorageFailpointLocation, DoStorageFailpointTestControl, DoValueBoundExceeded, LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, PortTransportError, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, boundPortDiagnostic, conversationStoreLayer, decodePortRequest, decodePortResponse, doMigrations, encodePortRequest, encodePortResponse, evictionFailpointHandler, executePortRequest, handleEncodedPortRequest, layer, ledgerLayer, observationOffsetAt, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, scheduleStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer };
+export { CurrentDoStorageVersion, DEFAULT_MAX_STORED_VALUE_BYTES, DoAppendConflict, DoCheckpointConflict, DoFenceRejected, DoLedgerError, DoScheduleAlarmControl, DoScheduleTransaction, DoStorageCompatibilityError, DoStorageConfig, DoStorageConfigValue, DoStorageCorruptionError, DoStorageError, DoStorageFailpoint, DoStorageFailpointError, DoStorageFailpointLocation, DoSubscriptionAlarmControl, DoSubscriptionTransaction, DoValueBoundExceeded, LedgerAdmitCall, LedgerAdmitResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, MAX_PORT_DIAGNOSTIC_LENGTH, PortFailed, PortFailure, PortProtocolError, PortRequest, PortResponse, PortResult, PortSucceeded, PortTransportError, StoreAppendCall, StoreAppendResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadPageCall, StoreReadPageResult, ThreadPortTransport, boundPortDiagnostic, decodePortRequest, decodePortResponse, doSubscriptionStoreLayer, encodePortRequest, encodePortResponse, executePortRequest, handleEncodedPortRequest, layer, ledgerLayer, observationOffsetAt, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer, scheduleStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, threadStoreLayer };
 
 //# sourceMappingURL=index.mjs.map