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

package/src/{do-conversation-store.ts → do-thread-store.ts}

@@ -6,17 +6,18 @@ import {
   CanonicalRecordEnvelope,
   CanonicalSequence,
   CheckpointRejected,
-  ConversationCheckpoint,
-  ConversationExport,
-  ConversationExportRequest,
-  ConversationMaterialization,
-  ConversationNotMaterialized,
-  ConversationObservation,
-  ConversationRead,
-  ConversationStore,
-  ConversationStoreError,
-  ConversationTail,
-  ConversationTailRequest,
+  ThreadCheckpoint,
+  ThreadExport,
+  ThreadExportRequest,
+  ThreadMaterialization,
+  ThreadNotMaterialized,
+  ThreadObservation,
+  ThreadRead,
+  ThreadStore,
+  type ThreadCheckpoints,
+  ThreadStoreError,
+  ThreadTail,
+  ThreadTailRequest,
   DEFAULT_OWNERSHIP_LEASE_DURATION,
   digestCanonicalBatch,
   Digest,
@@ -26,7 +27,7 @@ import {
   LoadCheckpointRequest,
   ObservationOffset,
   SaveCheckpointRequest,
-} from "@effect-agent/session";
+} from "@effect-agent/thread";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import {
@@ -76,7 +77,7 @@ export interface DoStorageOptions {
   readonly observationPollInterval?: number | undefined;
   /**
    * Submission ownership lease duration in milliseconds (D5). Defaults to
-   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/session`.
+   * `DEFAULT_OWNERSHIP_LEASE_DURATION` from `@effect-agent/thread`.
    */
   readonly ownershipLeaseDuration?: number | undefined;
   /**
@@ -107,27 +108,27 @@ const isDoAppendConflict = Schema.is(DoAppendConflict);
 const isDoCheckpointConflict = Schema.is(DoCheckpointConflict);
 
 const storeError = (operation: string, error: { readonly message: string }) =>
-  ConversationStoreError.make({
+  ThreadStoreError.make({
     cause: error,
     operation,
     message: error.message,
   });
 
 const schemaStoreError = (operation: string, error: { readonly message: string }) =>
-  ConversationStoreError.make({
+  ThreadStoreError.make({
     cause: error,
     operation,
     message: error.message,
   });
 
 const makeOffset = Effect.fn(function* (
-  conversationId: ConversationMaterialization["conversationId"],
+  threadId: ThreadMaterialization["threadId"],
   sequence: number,
-): Effect.fn.Return<ObservationOffset, ConversationStoreError> {
+): Effect.fn.Return<ObservationOffset, ThreadStoreError> {
   return yield* Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(
     Effect.flatMap((validatedSequence) =>
       Schema.decodeUnknownEffect(ObservationOffset)(
-        `${DO_OFFSET_PREFIX}${encodeURIComponent(conversationId)}:${validatedSequence}`,
+        `${DO_OFFSET_PREFIX}${encodeURIComponent(threadId)}:${validatedSequence}`,
       ),
     ),
     Effect.mapError((error) => schemaStoreError("encode observation offset", error)),
@@ -135,24 +136,23 @@ const makeOffset = Effect.fn(function* (
 });
 
 const parseOffset = Effect.fn(function* (
-  conversationId: ConversationMaterialization["conversationId"],
+  threadId: ThreadMaterialization["threadId"],
   offset: ObservationOffset | undefined,
-): Effect.fn.Return<CanonicalSequence, ConversationStoreError> {
+): Effect.fn.Return<CanonicalSequence, ThreadStoreError> {
   if (offset === undefined) 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);
+  const sequenceText = text.slice(threadPrefix.length);
   if (!/^(0|[1-9][0-9]*)$/.test(sequenceText)) {
-    return yield* ConversationStoreError.make({
+    return yield* ThreadStoreError.make({
       operation: "decode observation offset",
       message: "The observation offset is malformed.",
     });
@@ -162,19 +162,16 @@ const parseOffset = Effect.fn(function* (
   );
 });
 
-const mapFence = (
-  conversationId: ConversationMaterialization["conversationId"],
-  error: DoFenceRejected,
-) =>
+const mapFence = (threadId: ThreadMaterialization["threadId"], error: DoFenceRejected) =>
   FenceRejected.make({
-    conversationId,
+    threadId,
     actualEpoch: error.actualEpoch,
     attemptedEpoch: error.producerEpoch,
   });
 
 const encodeCanonicalRecord = Effect.fn(function* (
   record: CanonicalRecord,
-): Effect.fn.Return<string, ConversationStoreError> {
+): Effect.fn.Return<string, ThreadStoreError> {
   return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalRecord))(record).pipe(
     Effect.mapError((error) => schemaStoreError("encode canonical record", error)),
   );
@@ -182,23 +179,23 @@ const encodeCanonicalRecord = Effect.fn(function* (
 
 const encodeCanonicalBatch = Effect.fn(function* (
   batch: CanonicalBatch,
-): Effect.fn.Return<string, ConversationStoreError> {
+): Effect.fn.Return<string, ThreadStoreError> {
   return yield* Schema.encodeEffect(Schema.fromJsonString(CanonicalBatch))(batch).pipe(
     Effect.mapError((error) => schemaStoreError("encode canonical batch", error)),
   );
 });
 
 const encodeCheckpoint = Effect.fn(function* (
-  checkpoint: ConversationCheckpoint,
-): Effect.fn.Return<string, ConversationStoreError> {
-  return yield* Schema.encodeEffect(Schema.fromJsonString(ConversationCheckpoint))(checkpoint).pipe(
+  checkpoint: ThreadCheckpoint,
+): Effect.fn.Return<string, ThreadStoreError> {
+  return yield* Schema.encodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpoint).pipe(
     Effect.mapError((error) => schemaStoreError("encode checkpoint", error)),
   );
 });
 
 const decodeEnvelope = Effect.fn(function* (row: {
   readonly batch_id: string;
-  readonly conversation_id: string;
+  readonly thread_id: string;
   readonly record_json: string;
   readonly sequence: CanonicalSequence;
 }) {
@@ -206,23 +203,21 @@ const decodeEnvelope = Effect.fn(function* (row: {
     row.record_json,
   ).pipe(
     Effect.mapError((error) =>
-      ConversationStoreError.make({
+      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,
@@ -232,37 +227,37 @@ const decodeEnvelope = Effect.fn(function* (row: {
 
 const decodeCheckpoint = Effect.fn(function* (
   checkpointJson: string,
-): Effect.fn.Return<ConversationCheckpoint, ConversationStoreError> {
-  return yield* Schema.decodeEffect(Schema.fromJsonString(ConversationCheckpoint))(
-    checkpointJson,
-  ).pipe(Effect.mapError((error) => schemaStoreError("decode checkpoint", error)));
+): Effect.fn.Return<ThreadCheckpoint, ThreadStoreError> {
+  return yield* Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(checkpointJson).pipe(
+    Effect.mapError((error) => schemaStoreError("decode checkpoint", error)),
+  );
 });
 
-const requireConversation = Effect.fn("DoConversationStore.requireConversation")(function* (
+const requireThread = Effect.fn("DoThreadStore.requireThread")(function* (
   journal: DoJournal,
-  conversationId: ConversationMaterialization["conversationId"],
+  threadId: ThreadMaterialization["threadId"],
 ) {
   const rows = yield* journal
-    .getConversation(conversationId)
-    .pipe(Effect.mapError((error) => storeError("read conversation", error)));
+    .getThread(threadId)
+    .pipe(Effect.mapError((error) => storeError("read thread", error)));
   if (rows.length === 0) {
-    return yield* ConversationNotMaterialized.make({ conversationId });
+    return yield* ThreadNotMaterialized.make({ threadId });
   }
   return rows[0];
 });
 
-const tailDigestAt = Effect.fn("DoConversationStore.tailDigestAt")(function* (
+const tailDigestAt = Effect.fn("DoThreadStore.tailDigestAt")(function* (
   journal: DoJournal,
-  conversationId: ConversationMaterialization["conversationId"],
+  threadId: ThreadMaterialization["threadId"],
   sequence: CanonicalSequence,
 ) {
   if (sequence === 0) return EMPTY_TAIL_DIGEST;
   const digests = yield* journal
-    .getTailDigestAt(conversationId, sequence)
+    .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",
     });
   }
@@ -292,7 +287,7 @@ const groupByKey = <A>(
  * 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* (
+const decodeStartupPayloads = Effect.fn("DoThreadStore.decodeStartupPayloads")(function* (
   journal: DoJournal,
   crypto: Crypto.Crypto,
 ) {
@@ -303,7 +298,7 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
       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,
         }),
       ),
@@ -315,46 +310,41 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
       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(
+    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),
-  );
+  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 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);
+  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 = new Map<number, string>([[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 ||
@@ -437,27 +427,27 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
     }
 
     if (
-      conversationRecords.length !== conversation.tail_sequence ||
-      conversation.tail_sequence !== expectedSequence - 1 ||
-      conversation.tail_digest !== previousDigest
+      threadRecords.length !== thread.tail_sequence ||
+      thread.tail_sequence !== expectedSequence - 1 ||
+      thread.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.",
+        table: "effect_agent_threads",
+        rowKey: thread.thread_id,
+        message: "Thread tail does not match its canonical batch chain.",
       });
     }
 
-    for (const checkpoint of conversationCheckpoints) {
+    for (const checkpoint of threadCheckpoints) {
       if (
-        checkpoint.decoded.conversationId !== conversation.conversation_id ||
+        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.",
         });
       }
@@ -465,19 +455,19 @@ const decodeStartupPayloads = Effect.fn("DoConversationStore.decodeStartupPayloa
   }
 
   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))
+    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_conversations",
+      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 = Effect.fn("DoConversationStore.makeServices")(function* () {
+const makeServices = Effect.fn("DoThreadStore.makeServices")(function* () {
   const config = yield* DoStorageConfig;
   const failpoint = yield* DoStorageFailpoint;
   const sql = yield* SqlClientService.SqlClient;
@@ -490,142 +480,135 @@ const makeServices = Effect.fn("DoConversationStore.makeServices")(function* ()
   const provideCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
     Effect.provideService(effect, Crypto.Crypto, crypto);
   const hitFailpoint = Effect.fn(
-    (location: DoStorageFailpointLocation): Effect.Effect<void, ConversationStoreError> =>
+    (location: DoStorageFailpointLocation): Effect.Effect<void, ThreadStoreError> =>
       failpoint
         .hit(location)
         .pipe(Effect.mapError((error) => storeError(`storage failpoint ${location}`, error))),
   );
 
-  const materialize: ConversationStore["Service"]["materialize"] = Effect.fn(
-    "DoConversationStore.materialize",
-  )(function* (request: ConversationMaterialization) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationMaterialization))(
-      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* hitFailpoint("materialize:after");
-  });
-
-  const append: ConversationStore["Service"]["append"] = Effect.fn("DoConversationStore.append")(
-    function* (request: FencedAppendRequest) {
-      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(
+  const materialize: ThreadStore["Service"]["materialize"] = Effect.fn("DoThreadStore.materialize")(
+    function* (request: ThreadMaterialization) {
+      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadMaterialization))(
         request,
-      ).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
-      yield* requireConversation(journal, validated.conversationId);
-      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) => ({
-            recordId: record.recordId,
-            recordJson,
-          })),
-        ),
-      );
-      const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
-        conversationId: validated.conversationId,
-        batchId: validated.batch.batchId,
-        batchDigest: tailDigest,
-        batchJson,
-        expectedTailSequence: validated.expectedTailSequence,
-        expectedTailDigest: validated.expectedTailDigest,
-        producerEpoch: validated.producerEpoch,
-        records: rawRecords,
-        tailDigest,
-      }).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 (isDoAppendConflict(error)) {
-            return error.actualTailSequence !== undefined && isDigest(error.actualTailDigest)
-              ? AppendConflict.make({
-                  conversationId: validated.conversationId,
-                  batchId: validated.batch.batchId,
-                  reason: error.reason,
-                  actualTailSequence: error.actualTailSequence,
-                  actualTailDigest: error.actualTailDigest,
-                })
-              : AppendConflict.make({
-                  conversationId: validated.conversationId,
-                  batchId: validated.batch.batchId,
-                  reason: error.reason,
-                });
-          }
-          return storeError("append canonical batch", error);
-        }),
-        Effect.flatMap((result) =>
-          Schema.decodeUnknownEffect(AppendResult)(result).pipe(
-            Effect.mapError((error) => schemaStoreError("decode append result", error)),
+      ).pipe(Effect.mapError((error) => schemaStoreError("validate materialization", error)));
+      const now = yield* Clock.currentTimeMillis;
+      yield* hitFailpoint("materialize:before");
+      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("append:after");
-      return result;
+        );
+      yield* hitFailpoint("materialize:after");
     },
   );
 
-  const loadRecords = Effect.fn("DoConversationStore.loadRecords")(function* (
-    request: RawReadRequest,
+  const append: ThreadStore["Service"]["append"] = Effect.fn("DoThreadStore.append")(function* (
+    request: FencedAppendRequest,
   ) {
+    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(FencedAppendRequest))(
+      request,
+    ).pipe(Effect.mapError((error) => schemaStoreError("validate canonical append", error)));
+    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) => ({
+          recordId: record.recordId,
+          recordJson,
+        })),
+      ),
+    );
+    const rawRequest = yield* Schema.decodeUnknownEffect(RawAppendRequest)({
+      threadId: validated.threadId,
+      batchId: validated.batch.batchId,
+      batchDigest: tailDigest,
+      batchJson,
+      expectedTailSequence: validated.expectedTailSequence,
+      expectedTailDigest: validated.expectedTailDigest,
+      producerEpoch: validated.producerEpoch,
+      records: rawRecords,
+      tailDigest,
+    }).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.threadId, error);
+        }
+        if (isDoAppendConflict(error)) {
+          return error.actualTailSequence !== undefined && isDigest(error.actualTailDigest)
+            ? AppendConflict.make({
+                threadId: validated.threadId,
+                batchId: validated.batch.batchId,
+                reason: error.reason,
+                actualTailSequence: error.actualTailSequence,
+                actualTailDigest: error.actualTailDigest,
+              })
+            : AppendConflict.make({
+                threadId: validated.threadId,
+                batchId: validated.batch.batchId,
+                reason: error.reason,
+              });
+        }
+        return storeError("append canonical batch", error);
+      }),
+      Effect.flatMap((result) =>
+        Schema.decodeUnknownEffect(AppendResult)(result).pipe(
+          Effect.mapError((error) => schemaStoreError("decode append result", error)),
+        ),
+      ),
+    );
+    yield* hitFailpoint("append:after");
+    return result;
+  });
+
+  const loadRecords = Effect.fn("DoThreadStore.loadRecords")(function* (request: RawReadRequest) {
     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: ConversationRead) {
-    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: ThreadRead) {
+    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: ConversationStore["Service"]["read"] = (request) =>
-    Stream.unwrap(readEffect(request));
+  const read: ThreadStore["Service"]["read"] = (request) => Stream.unwrap(readEffect(request));
 
-  const observeEffect = Effect.fn("DoConversationStore.observe")(function* (
-    request: ConversationObservation,
-  ) {
-    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ConversationObservation))(
+  const observeEffect = Effect.fn("DoThreadStore.observe")(function* (request: ThreadObservation) {
+    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(ThreadObservation))(
       request,
-    ).pipe(
-      Effect.mapError((error) => schemaStoreError("validate conversation observation", error)),
-    );
-    yield* requireConversation(journal, validated.conversationId);
-    const initialSequence = yield* parseOffset(validated.conversationId, validated.afterOffset);
+    ).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: 1_024,
         }),
@@ -639,163 +622,159 @@ const makeServices = Effect.fn("DoConversationStore.makeServices")(function* ()
     });
     return Stream.fromIterableEffectRepeat(poll());
   });
-  const observe: ConversationStore["Service"]["observe"] = (request) =>
+  const observe: ThreadStore["Service"]["observe"] = (request) =>
     Stream.unwrap(observeEffect(request));
 
-  const exportConversation: ConversationStore["Service"]["export"] = Effect.fn(
-    "DoConversationStore.export",
-  )(function* (request: ConversationExportRequest) {
-    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 records = yield* Effect.forEach(exported.records, decodeEnvelope);
-    if (records.length > 65_536) {
-      return yield* ConversationStoreError.make({
-        operation: "decode conversation export",
-        message: "The conversation exceeds the current export record limit.",
+  const exportThread: ThreadStore["Service"]["export"] = Effect.fn("DoThreadStore.export")(
+    function* (request: ThreadExportRequest) {
+      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 > 65_536) {
+        return yield* ThreadStoreError.make({
+          operation: "decode thread export",
+          message: "The thread exceeds the current export record limit.",
+        });
+      }
+      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 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,
-      tailDigest,
-      records,
-    });
-  });
-
-  const inspectTail: ConversationStore["Service"]["inspectTail"] = Effect.fn(
-    "DoConversationStore.inspectTail",
-  )(function* (request: ConversationTailRequest) {
-    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,
-      tailDigest,
-      producerEpoch: conversation.producer_epoch,
-    });
-  });
+    },
+  );
 
-  const saveCheckpoint: ConversationStore["Service"]["saveCheckpoint"] = Effect.fn(
-    "DoConversationStore.saveCheckpoint",
-  )(function* (request: SaveCheckpointRequest) {
-    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,
-        reason: "ahead-of-tail",
-      });
-    }
-    const canonicalDigest = yield* tailDigestAt(
-      journal,
-      validated.checkpoint.conversationId,
-      validated.checkpoint.throughSequence,
-    );
-    if (canonicalDigest !== validated.checkpoint.tailDigest) {
-      return yield* CheckpointRejected.make({
-        conversationId: validated.checkpoint.conversationId,
-        reason: "digest-mismatch",
+  const inspectTail: ThreadStore["Service"]["inspectTail"] = Effect.fn("DoThreadStore.inspectTail")(
+    function* (request: ThreadTailRequest) {
+      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: thread.producer_epoch,
       });
-    }
-    const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
-    const raw = RawCheckpoint.make({
-      conversationId: validated.checkpoint.conversationId,
-      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,
-              reason: "digest-mismatch",
-            })
-          : storeError("save checkpoint", error),
-      ),
-    );
-    yield* hitFailpoint("save-checkpoint:after");
-  });
+    },
+  );
 
-  const loadCheckpoint: ConversationStore["Service"]["loadCheckpoint"] = Effect.fn(
-    "DoConversationStore.loadCheckpoint",
-  )(function* (request: LoadCheckpointRequest) {
-    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)));
-    if (rows.length === 0) return Option.none();
-    if (rows.length !== 1) {
-      return yield* ConversationStoreError.make({
-        operation: "load checkpoint",
-        message: `Expected at most one checkpoint row but found ${rows.length}.`,
-      });
-    }
-    const checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
-    const canonicalDigest = yield* tailDigestAt(
-      journal,
-      checkpoint.conversationId,
-      checkpoint.throughSequence,
-    );
-    if (canonicalDigest !== checkpoint.tailDigest) {
-      return yield* CheckpointRejected.make({
-        conversationId: checkpoint.conversationId,
-        reason: "digest-mismatch",
+  const saveCheckpoint: ThreadCheckpoints["save"] = Effect.fn("DoThreadStore.saveCheckpoint")(
+    function* (request: SaveCheckpointRequest) {
+      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(SaveCheckpointRequest))(
+        request,
+      ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint", error)));
+      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",
+        });
+      }
+      const canonicalDigest = yield* tailDigestAt(
+        journal,
+        validated.checkpoint.threadId,
+        validated.checkpoint.throughSequence,
+      );
+      if (canonicalDigest !== validated.checkpoint.tailDigest) {
+        return yield* CheckpointRejected.make({
+          threadId: validated.checkpoint.threadId,
+          reason: "digest-mismatch",
+        });
+      }
+      const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
+      const raw = RawCheckpoint.make({
+        threadId: validated.checkpoint.threadId,
+        throughSequence: validated.checkpoint.throughSequence,
+        tailDigest: validated.checkpoint.tailDigest,
+        checkpointJson,
       });
-    }
-    return Option.some(checkpoint);
-  });
+      yield* hitFailpoint("save-checkpoint:before");
+      yield* journal.saveCheckpoint(raw).pipe(
+        Effect.mapError((error) =>
+          isDoCheckpointConflict(error)
+            ? CheckpointRejected.make({
+                threadId: validated.checkpoint.threadId,
+                reason: "digest-mismatch",
+              })
+            : storeError("save checkpoint", error),
+        ),
+      );
+      yield* hitFailpoint("save-checkpoint:after");
+    },
+  );
+
+  const loadCheckpoint: ThreadCheckpoints["load"] = Effect.fn("DoThreadStore.loadCheckpoint")(
+    function* (request: LoadCheckpointRequest) {
+      const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(
+        request,
+      ).pipe(Effect.mapError((error) => schemaStoreError("validate checkpoint lookup", 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* ThreadStoreError.make({
+          operation: "load checkpoint",
+          message: `Expected at most one checkpoint row but found ${rows.length}.`,
+        });
+      }
+      const checkpoint = yield* decodeCheckpoint(rows[0].checkpoint_json);
+      const canonicalDigest = yield* tailDigestAt(
+        journal,
+        checkpoint.threadId,
+        checkpoint.throughSequence,
+      );
+      if (canonicalDigest !== 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.
  */
-export const conversationStoreLayer: Layer.Layer<
-  ConversationStore,
+export const threadStoreLayer: Layer.Layer<
+  ThreadStore,
   DoStorageInitializationError,
   DoStorageConfig | DoStorageFailpoint | SqlClientService.SqlClient | Crypto.Crypto
 > = Layer.effectContext(makeServices());
 
 /**
  * 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.
  */
 export const storageConfigLayer = (
@@ -828,17 +807,17 @@ export const storageFailpointLayer = (
     : 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).
  */
 export const layer = (
   options: DoStorageOptions,
-): Layer.Layer<ConversationStore, DoStorageInitializationError> =>
+): Layer.Layer<ThreadStore, DoStorageInitializationError> =>
   Layer.unwrap(
     Effect.map(DoStorageConfig, (config) =>
-      conversationStoreLayer.pipe(
+      threadStoreLayer.pipe(
         Layer.provide(
           Layer.mergeAll(
             Layer.succeed(DoStorageConfig)(config),