@effect-agent/storage-sqlite 0.1.0-beta.6 → 0.1.0-beta.60

package/src/{sqlite-journal.ts → internal/sqlite-journal.ts}

@@ -1,26 +1,40 @@
-import { CanonicalSequence, ProducerEpoch } from "@effect-agent/session";
+import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread/Records";
+import { ScheduleFailpoint, ScheduleFailpointError } from "@effect-agent/thread/Schedule";
+import {
+  checkV2ThreadLayout,
+  upgradeV2Schedules,
+  upgradeV2Subscriptions,
+} from "@effect-agent/thread/SqlStorageV2Upgrade";
+import {
+  SubscriptionFailpoint,
+  SubscriptionFailpointError,
+} from "@effect-agent/thread/Subscription";
+import { NodeCrypto } from "@effect/platform-node";
 import { SqliteMigrator } from "@effect/sql-sqlite-node";
 import { Effect, Exit, Schema } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 
+import { SqliteStorageConfig } from "../SqliteStorageConfig.ts";
+import type { SqliteStorageFailpointError } from "../SqliteStorageError.ts";
 import {
   SqliteAppendConflict,
   SqliteCheckpointConflict,
   SqliteFenceRejected,
   SqliteStorageCompatibilityError,
+  SqliteStorageFailpointLocation,
   SqliteStorageCorruptionError,
   SqliteStorageError,
-  SqliteStorageFailpointError,
   SqliteWriteContention,
-  type SqliteStorageFailpointLocation,
-} from "./errors.ts";
+} from "../SqliteStorageError.ts";
+import { SqliteStorageFailpoint } from "../SqliteStorageFailpoint.ts";
+import { createMessageDeliveryTables } from "./message-delivery-schema.ts";
 import { CurrentSqliteStorageVersion, sqliteMigrations } from "./migrations.ts";
 
 const BoundedStoredText = Schema.String.check(Schema.isMaxLength(16 * 1024 * 1024));
 const BoundedIdentifier = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
 const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-const MAX_RECORDS_PER_CONVERSATION = 65_536;
+const MAX_RECORDS_PER_THREAD = 65_536;
 const MAX_STORED_TEXT_BYTES = 16 * 1024 * 1024;
 const MAX_IDENTIFIER_LENGTH = 1_024;
 
@@ -38,8 +52,8 @@ class SqliteNameRow extends Schema.Class<SqliteNameRow>("SqliteNameRow")({
   name: BoundedIdentifier,
 }) {}
 
-class ConversationRow extends Schema.Class<ConversationRow>("ConversationRow")({
-  conversation_id: BoundedIdentifier,
+class ThreadRow extends Schema.Class<ThreadRow>("ThreadRow")({
+  thread_id: BoundedIdentifier,
   created_at: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
   producer_epoch: ProducerEpoch,
   tail_digest: BoundedStoredText,
@@ -50,7 +64,7 @@ class BatchRow extends Schema.Class<BatchRow>("BatchRow")({
   batch_digest: BoundedStoredText,
   batch_id: BoundedIdentifier,
   batch_json: BoundedStoredText,
-  conversation_id: BoundedIdentifier,
+  thread_id: BoundedIdentifier,
   first_sequence: CanonicalSequence,
   last_sequence: CanonicalSequence,
   tail_digest: BoundedStoredText,
@@ -58,7 +72,7 @@ class BatchRow extends Schema.Class<BatchRow>("BatchRow")({
 
 class RecordRow extends Schema.Class<RecordRow>("RecordRow")({
   batch_id: BoundedIdentifier,
-  conversation_id: BoundedIdentifier,
+  thread_id: BoundedIdentifier,
   record_id: BoundedIdentifier,
   record_json: BoundedStoredText,
   sequence: CanonicalSequence,
@@ -66,7 +80,7 @@ class RecordRow extends Schema.Class<RecordRow>("RecordRow")({
 
 class CheckpointRow extends Schema.Class<CheckpointRow>("CheckpointRow")({
   checkpoint_json: BoundedStoredText,
-  conversation_id: BoundedIdentifier,
+  thread_id: BoundedIdentifier,
   tail_digest: BoundedStoredText,
   through_sequence: CanonicalSequence,
 }) {}
@@ -82,7 +96,7 @@ export class RawAppendRequest extends Schema.Class<RawAppendRequest>(
   batchDigest: BoundedStoredText,
   batchId: BoundedIdentifier,
   batchJson: BoundedStoredText,
-  conversationId: BoundedIdentifier,
+  threadId: BoundedIdentifier,
   expectedTailDigest: BoundedStoredText,
   expectedTailSequence: CanonicalSequence,
   producerEpoch: ProducerEpoch,
@@ -102,7 +116,7 @@ export class RawAppendResult extends Schema.Class<RawAppendResult>(
 export class RawReadRequest extends Schema.Class<RawReadRequest>(
   "@effect-agent/storage-sqlite/RawReadRequest",
 )({
-  conversationId: BoundedIdentifier,
+  threadId: BoundedIdentifier,
   fromSequenceExclusive: CanonicalSequence,
   limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1_024)),
 }) {}
@@ -111,17 +125,15 @@ export class RawCheckpoint extends Schema.Class<RawCheckpoint>(
   "@effect-agent/storage-sqlite/RawCheckpoint",
 )({
   checkpointJson: BoundedStoredText,
-  conversationId: BoundedIdentifier,
+  threadId: BoundedIdentifier,
   tailDigest: BoundedStoredText,
   throughSequence: CanonicalSequence,
 }) {}
 
-export class RawConversationExport extends Schema.Class<RawConversationExport>(
-  "@effect-agent/storage-sqlite/RawConversationExport",
+export class RawThreadExport extends Schema.Class<RawThreadExport>(
+  "@effect-agent/storage-sqlite/RawThreadExport",
 )({
-  batches: Schema.Array(BatchRow),
-  checkpoints: Schema.Array(CheckpointRow),
-  conversation: ConversationRow,
+  thread: ThreadRow,
   records: Schema.Array(RecordRow),
 }) {}
 
@@ -138,11 +150,6 @@ type CheckpointError =
   | SqliteStorageCorruptionError
   | SqliteStorageError
   | SqliteWriteContention;
-type SqliteJournalFailpoint = (
-  location: SqliteStorageFailpointLocation,
-) => Effect.Effect<void, SqliteStorageFailpointError>;
-
-const noFailpoint: SqliteJournalFailpoint = () => Effect.void;
 
 const storageError =
   (operation: string) =>
@@ -195,26 +202,219 @@ export const decodeSingleRow = Effect.fn("SqliteJournal.decodeSingleRow")(
     ),
 );
 
-const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(function* (
-  sql: SqlClient.SqlClient,
-  failpoint: SqliteJournalFailpoint = noFailpoint,
-  busyTimeoutMillis = 5_000,
-) {
+/** Column inventory of the supported v8 predecessor, independent of physical column order. */
+const predecessorColumns = {
+  effect_agent_threads: [
+    "thread_id",
+    "created_at",
+    "tail_sequence",
+    "tail_digest",
+    "producer_epoch",
+  ],
+  effect_agent_canonical_batches: [
+    "thread_id",
+    "batch_id",
+    "first_sequence",
+    "last_sequence",
+    "batch_digest",
+    "tail_digest",
+    "batch_json",
+  ],
+  effect_agent_canonical_records: ["thread_id", "sequence", "record_id", "batch_id", "record_json"],
+  effect_agent_checkpoints: ["thread_id", "through_sequence", "tail_digest", "checkpoint_json"],
+  effect_agent_submissions: [
+    "submission_id",
+    "thread_id",
+    "queue_sequence",
+    "principal",
+    "idempotency_key",
+    "agent_id",
+    "agent_digests_json",
+    "deployment_id",
+    "input_json",
+    "input_digest",
+    "receipt_id",
+    "state",
+    "settled_outcome",
+    "created_at",
+    "ready_at",
+    "input_applied_record_id",
+    "input_applied_sequence",
+    "joined_host_submission_id",
+    "suspended_reason_json",
+    "suspended_at",
+    "unknown_reason",
+    "unknown_tool_call_ids_json",
+    "parent_submission_id",
+    "parent_tool_call_id",
+    "admission_group",
+    "admission_fence_json",
+  ],
+  effect_agent_submission_ownership: [
+    "submission_id",
+    "attempt_id",
+    "ownership_token",
+    "producer_epoch",
+    "owner_producer_id",
+    "lease_expires_at",
+  ],
+  effect_agent_attempts: [
+    "attempt_id",
+    "submission_id",
+    "thread_id",
+    "owner_producer_id",
+    "producer_epoch",
+    "claimed_at",
+  ],
+  effect_agent_settlement_reservations: [
+    "submission_id",
+    "settlement_id",
+    "outcome",
+    "record_id",
+    "record_json",
+    "record_digest",
+    "reserved_at",
+    "finalized_at",
+  ],
+  effect_agent_abort_intents: [
+    "submission_id",
+    "author",
+    "reason",
+    "requested_at",
+    "canonical_record_id",
+  ],
+  effect_agent_approval_decisions: [
+    "submission_id",
+    "tool_call_id",
+    "decision",
+    "resolver",
+    "reason",
+    "decided_at",
+  ],
+  effect_agent_unknown_resolutions: [
+    "submission_id",
+    "tool_call_id",
+    "author",
+    "reason",
+    "resolution_json",
+    "resolved_at",
+  ],
+  effect_agent_child_reservations: [
+    "reservation_id",
+    "parent_submission_id",
+    "parent_tool_call_id",
+    "child_submission_id",
+    "status",
+    "allocation_json",
+    "allocation_digest",
+    "accounting_json",
+    "reserved_at",
+    "release_began_at",
+    "released_at",
+  ],
+  effect_agent_schedules: [
+    "tenant_id",
+    "owner_id",
+    "schedule_id",
+    "deadline_at_millis",
+    "record_json",
+  ],
+  effect_agent_subscription_sequences: [
+    "tenant_id",
+    "source_address",
+    "sequence",
+    "event_scan_cursor",
+    "delivery_scan_cursor",
+    "recovery_scan_cursor",
+  ],
+  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",
+    "recovery_present",
+    "record_json",
+  ],
+  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",
+    "tombstone",
+  ],
+  effect_agent_subscription_deliveries: [
+    "tenant_id",
+    "source_address",
+    "owner_id",
+    "subscription_id",
+    "event_id",
+    "delivery_key",
+    "state",
+    "next_attempt_at_millis",
+    "record_json",
+  ],
+} as const;
+
+const checkPredecessorLayout = Effect.fn("SqliteJournal.checkPredecessorLayout")(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  for (const [table, expected] of Object.entries(predecessorColumns)) {
+    const columns = yield* decodeRows(
+      Schema.Array(Schema.Struct({ name: BoundedIdentifier })),
+      table,
+      "schema",
+      yield* sql.unsafe(`PRAGMA table_info(${table})`),
+    );
+
+    const names = new Set<string>(expected);
+
+    if (columns.length !== names.size || columns.some((column) => !names.has(column.name)))
+      return yield* SqliteStorageCompatibilityError.make({
+        actualVersion: 8,
+        supportedVersion: CurrentSqliteStorageVersion,
+        message: `The v8 ${table} columns do not match the supported predecessor; no upgrade was committed.`,
+      });
+  }
+});
+
+export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const { hit: failpoint } = yield* SqliteStorageFailpoint;
+  const { busyTimeout } = yield* SqliteStorageConfig;
+
   yield* sql`PRAGMA foreign_keys = ON`.pipe(Effect.mapError(storageError("enable foreign keys")));
   // PRAGMA statements do not accept bound parameters; the value is a schema-validated
   // non-negative integer, never caller-controlled text.
   yield* sql
-    .unsafe(`PRAGMA busy_timeout = ${busyTimeoutMillis}`)
+    .unsafe(`PRAGMA busy_timeout = ${busyTimeout}`)
     .pipe(Effect.mapError(storageError("configure busy timeout")));
+
   const journalModeRows = yield* sql<Record<string, unknown>>`PRAGMA journal_mode`.pipe(
     Effect.mapError(storageError("read journal mode")),
   );
+
   const journalMode = yield* decodeSingleRow(
     Schema.Array(SqliteJournalModeRow),
     "pragma_journal_mode",
     "singleton",
     journalModeRows,
   );
+
   if (journalMode.journal_mode.toLowerCase() !== "wal") {
     return yield* SqliteStorageCompatibilityError.make({
       actualVersion: 0,
@@ -226,6 +426,7 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
   const versionRows = yield* sql<Record<string, unknown>>`PRAGMA user_version`.pipe(
     Effect.mapError(storageError("read storage version")),
   );
+
   const version = yield* decodeSingleRow(
     Schema.Array(SqliteVersionRow),
     "pragma_user_version",
@@ -233,20 +434,137 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
     versionRows,
   );
 
-  // D7: the storage version must match EXACTLY (or be 0 for a fresh file). Older
-  // private-development versions fail closed with reset guidance rather than being
-  // migrated, and newer versions fail closed rather than being decoded incorrectly.
-  if (version.user_version !== 0 && version.user_version !== CurrentSqliteStorageVersion) {
+  // Support the known beta49/beta50 and immediate predecessor formats atomically.
+  if (
+    version.user_version !== 0 &&
+    version.user_version !== 7 &&
+    version.user_version !== 8 &&
+    version.user_version !== CurrentSqliteStorageVersion
+  ) {
     return yield* SqliteStorageCompatibilityError.make({
       actualVersion: version.user_version,
       supportedVersion: CurrentSqliteStorageVersion,
       message:
-        `The SQLite file uses private-development storage version ${version.user_version}; ` +
+        `The SQLite file uses unsupported storage version ${version.user_version}; ` +
         `this build supports exactly version ${CurrentSqliteStorageVersion}. ` +
-        "Reset the database file explicitly; automatic stored-data migrations are not provided during private development.",
+        "Only supported v7 and v8 can be upgraded automatically. Keep the original file and use a compatible library version.",
     });
   }
 
+  if (version.user_version === 7 || version.user_version === 8) {
+    yield* sql
+      .withTransaction(
+        Effect.gen(function* () {
+          const current = yield* sql<{ user_version: number }>`PRAGMA user_version`;
+
+          if (current.length === 1 && current[0].user_version === CurrentSqliteStorageVersion)
+            return;
+          if (
+            current.length !== 1 ||
+            (current[0].user_version !== 7 && current[0].user_version !== 8)
+          )
+            return yield* SqliteStorageCompatibilityError.make({
+              actualVersion: -1,
+              supportedVersion: CurrentSqliteStorageVersion,
+              message: "Storage version changed while acquiring the upgrade transaction.",
+            });
+
+          const required = yield* sql<{
+            name: string;
+          }>`SELECT name FROM sqlite_master WHERE type='table' AND name IN (
+            'effect_agent_threads', 'effect_agent_canonical_batches', 'effect_agent_canonical_records',
+            'effect_agent_checkpoints', 'effect_agent_submissions', 'effect_agent_submission_ownership',
+            'effect_agent_attempts', 'effect_agent_settlement_reservations', 'effect_agent_abort_intents',
+            'effect_agent_approval_decisions', 'effect_agent_unknown_resolutions', 'effect_agent_schedules'
+          )`;
+
+          if (required.length !== 12)
+            return yield* SqliteStorageCompatibilityError.make({
+              actualVersion: current[0].user_version,
+              supportedVersion: CurrentSqliteStorageVersion,
+              message:
+                "The predecessor store is missing required tables; no upgrade was committed.",
+            });
+
+          if (current[0].user_version === 7) {
+            yield* checkV2ThreadLayout();
+            for (const statement of [
+              sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_group TEXT`,
+              sql`ALTER TABLE effect_agent_submissions ADD COLUMN admission_fence_json TEXT`,
+              sql`CREATE INDEX effect_agent_submissions_group ON effect_agent_submissions (thread_id, admission_group, state)`,
+            ]) {
+              yield* failpoint("upgrade:before-mutation");
+              yield* statement;
+              yield* failpoint("upgrade:after-mutation");
+            }
+            yield* upgradeV2Schedules(16 * 1024 * 1024).pipe(
+              Effect.provideService(ScheduleFailpoint, {
+                hit: (point) =>
+                  Schema.decodeUnknownEffect(SqliteStorageFailpointLocation)(point).pipe(
+                    Effect.flatMap(failpoint),
+                    Effect.mapError(() => ScheduleFailpointError.make({ point })),
+                  ),
+              }),
+            );
+            yield* upgradeV2Subscriptions(16 * 1024 * 1024).pipe(
+              Effect.provideService(SubscriptionFailpoint, {
+                hit: (point) =>
+                  Schema.decodeUnknownEffect(SqliteStorageFailpointLocation)(point).pipe(
+                    Effect.flatMap(failpoint),
+                    Effect.mapError(() => SubscriptionFailpointError.make({ point })),
+                  ),
+              }),
+            );
+          }
+          if (current[0].user_version === 8) yield* checkPredecessorLayout();
+          yield* failpoint("upgrade:before-mutation");
+          yield* sql`ALTER TABLE effect_agent_submissions ADD COLUMN worker_admission_json TEXT`;
+          yield* failpoint("upgrade:after-mutation");
+          yield* failpoint("upgrade:before-mutation");
+          yield* sql`ALTER TABLE effect_agent_submissions ADD COLUMN message_admission_json TEXT`;
+          yield* failpoint("upgrade:after-mutation");
+          yield* failpoint("upgrade:before-mutation");
+          yield* createMessageDeliveryTables;
+          yield* failpoint("upgrade:after-mutation");
+          yield* failpoint("upgrade:before-version");
+          yield* sql`PRAGMA user_version = 9`;
+          yield* failpoint("upgrade:after-version");
+        }),
+      )
+      .pipe(
+        Effect.provide(NodeCrypto.layer),
+        Effect.catchTag("SqliteStorageFailpointError", (error) =>
+          SqliteStorageError.make({
+            cause: error,
+            operation: "upgrade storage",
+            message: error.message,
+          }),
+        ),
+        Effect.catchTag(["ScheduleFailpointError", "SubscriptionFailpointError"], (error) =>
+          SqliteStorageError.make({
+            cause: error,
+            operation: "upgrade storage",
+            message: "Injected storage upgrade failure",
+          }),
+        ),
+        Effect.catchTag("StorageUpgradeError", (error) =>
+          SqliteStorageCorruptionError.make({
+            table: error.table,
+            rowKey: error.rowKey,
+            message: error.message,
+          }),
+        ),
+        Effect.catchTag("SqlError", storageError("upgrade supported storage")),
+        Effect.catchTag("SchemaError", (error) =>
+          SqliteStorageCorruptionError.make({
+            table: "upgrade",
+            rowKey: "v7",
+            message: error.message,
+          }),
+        ),
+      );
+  }
+
   if (version.user_version === 0) {
     const existingRows = yield* sql<Record<string, unknown>>`
       SELECT name
@@ -255,6 +573,7 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
         AND name LIKE 'effect_agent_%'
       ORDER BY name
     `.pipe(Effect.mapError(storageError("inspect unversioned storage")));
+
     const existing = yield* decodeRows(
       Schema.Array(SqliteNameRow),
       "sqlite_master",
@@ -267,14 +586,11 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
         actualVersion: 0,
         supportedVersion: CurrentSqliteStorageVersion,
         message:
-          "The SQLite file contains unversioned Effect Agent tables. Reset it explicitly; refusing to mutate ambiguous stored data.",
+          "The SQLite file contains unversioned Effect Agent tables. Refusing to mutate ambiguous stored data; retain it for inspection with its original writer.",
       });
     }
 
     yield* SqliteMigrator.run({ loader: sqliteMigrations }).pipe(
-      // SqliteMigrator depends on the generic client supplied by this adapter.
-      // The concrete Node client is kept at the outer Layer boundary.
-      Effect.provideService(SqlClient.SqlClient, sql),
       Effect.mapError((error) =>
         SqliteStorageError.make({
           cause: error,
@@ -290,7 +606,7 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
     FROM sqlite_master
     WHERE type = 'table'
       AND name IN (
-        'effect_agent_conversations',
+        'effect_agent_threads',
         'effect_agent_canonical_batches',
         'effect_agent_canonical_records',
         'effect_agent_checkpoints',
@@ -300,29 +616,29 @@ const ensureCurrentStorage = Effect.fn("SqliteJournal.ensureCurrentStorage")(fun
         'effect_agent_settlement_reservations',
         'effect_agent_abort_intents',
         'effect_agent_approval_decisions',
-        'effect_agent_unknown_resolutions'
+        'effect_agent_unknown_resolutions',
+        'effect_agent_schedules',
+        'effect_agent_message_deliveries'
       )
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
+
   const required = yield* decodeRows(
     Schema.Array(SqliteNameRow),
     "sqlite_master",
     "required_tables",
     requiredRows,
   );
-  if (required.length !== 11) {
+
+  if (required.length !== 13) {
     return yield* SqliteStorageCompatibilityError.make({
       actualVersion: CurrentSqliteStorageVersion,
       supportedVersion: CurrentSqliteStorageVersion,
       message:
-        "The SQLite file claims the current format but is missing required tables. Reset the corrupt private-development data.",
+        "The SQLite file claims the current format but is missing required tables. Retain the original store for inspection.",
     });
   }
 
-  return makeJournal(sql, failpoint);
-});
-
-const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint) => {
   const classifyWriteFailure =
     (operation: string) =>
     (error: SqlError): SqliteStorageError | SqliteWriteContention =>
@@ -357,19 +673,24 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
             const connection = yield* sql.reserve.pipe(
               Effect.mapError(classifyWriteFailure(operation)),
             );
+
             yield* connection
               .executeUnprepared("BEGIN IMMEDIATE", [], undefined)
               .pipe(Effect.mapError(classifyWriteFailure(operation)));
+
             const exit = yield* restore(
               Effect.provideService(effect, sql.transactionService, [connection, 0] as const),
             ).pipe(Effect.exit);
+
             if (Exit.isSuccess(exit)) {
               yield* connection
                 .executeUnprepared("COMMIT", [], undefined)
                 .pipe(Effect.mapError(classifyWriteFailure(operation)));
+
               return exit.value;
             }
             yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], undefined));
+
             return yield* exit;
           }),
         ).pipe(
@@ -392,26 +713,31 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         Effect.scoped(
           Effect.gen(function* () {
             const connection = yield* sql.reserve.pipe(Effect.mapError(storageError(operation)));
+
             yield* connection
               .executeUnprepared("BEGIN", [], undefined)
               .pipe(Effect.mapError(storageError(operation)));
+
             const exit = yield* restore(
               Effect.provideService(effect, sql.transactionService, [connection, 0] as const),
             ).pipe(Effect.exit);
+
             if (Exit.isSuccess(exit)) {
               yield* connection
                 .executeUnprepared("COMMIT", [], undefined)
                 .pipe(Effect.mapError(storageError(operation)));
+
               return exit.value;
             }
             yield* Effect.orDie(connection.executeUnprepared("ROLLBACK", [], undefined));
+
             return yield* exit;
           }),
         ).pipe(Effect.withSpan("SqliteJournal.withReadTransaction", { attributes: { operation } })),
       );
 
   const materialize = Effect.fn("SqliteJournal.materialize")(function* (
-    conversationId: string,
+    threadId: string,
     createdAt: string,
     emptyTailDigest: string,
     producerEpoch: ProducerEpoch,
@@ -420,55 +746,58 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
     SqliteFenceRejected | SqliteStorageCorruptionError | SqliteStorageError | SqliteWriteContention
   > {
     if (
-      conversationId.length > MAX_IDENTIFIER_LENGTH ||
+      threadId.length > MAX_IDENTIFIER_LENGTH ||
       storedTextBytes(emptyTailDigest) > MAX_STORED_TEXT_BYTES
     ) {
       return yield* SqliteStorageError.make({
-        operation: "materialize conversation",
-        message: "Conversation identity or initial digest exceeds the SQLite storage bounds.",
+        operation: "materialize thread",
+        message: "Thread identity or initial digest exceeds the SQLite storage bounds.",
       });
     }
     yield* withWriteTransaction("materialize transaction")(
       Effect.gen(function* () {
         const existingRows = yield* sql<Record<string, unknown>>`
           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")));
+          FROM effect_agent_threads
+          WHERE thread_id = ${threadId}
+        `.pipe(Effect.mapError(storageError("read materialized thread")));
+
         const existing = yield* decodeRows(
-          Schema.Array(ConversationRow),
-          "effect_agent_conversations",
-          conversationId,
+          Schema.Array(ThreadRow),
+          "effect_agent_threads",
+          threadId,
           existingRows,
         );
+
         if (existing.length > 1) {
           return yield* SqliteStorageCorruptionError.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) {
@@ -480,41 +809,35 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         }
         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("SqliteJournal.getConversation")(function* (
-    conversationId: string,
-  ) {
+  const getThread = Effect.fn("SqliteJournal.getThread")(function* (threadId: string) {
     const rows = yield* sql<Record<string, unknown>>`
       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(
-      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(Schema.Array(ThreadRow), "effect_agent_threads", threadId, rows);
   });
 
   const append = Effect.fn("SqliteJournal.append")(function* (
     request: RawAppendRequest,
   ): Effect.fn.Return<RawAppendResult, AppendError> {
     if (
-      request.conversationId.length > MAX_IDENTIFIER_LENGTH ||
+      request.threadId.length > MAX_IDENTIFIER_LENGTH ||
       request.batchId.length > MAX_IDENTIFIER_LENGTH ||
       storedTextBytes(request.batchJson) > MAX_STORED_TEXT_BYTES ||
       storedTextBytes(request.batchDigest) > MAX_STORED_TEXT_BYTES ||
@@ -530,9 +853,11 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         message: "Canonical identifiers or encoded JSON exceed the SQLite storage bounds.",
       });
     }
+
     return yield* withWriteTransaction("append transaction")(
       Effect.gen(function* () {
         const recordIds = request.records.map((record) => record.recordId);
+
         if (new Set(recordIds).size !== recordIds.length) {
           return yield* SqliteAppendConflict.make({
             message: `Batch ${request.batchId} contains duplicate canonical record IDs.`,
@@ -540,34 +865,35 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
           });
         }
 
-        const conversationRows = yield* sql<Record<string, unknown>>`
+        const threadRows = yield* sql<Record<string, unknown>>`
           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,
+
+        const thread = yield* decodeSingleRow(
+          Schema.Array(ThreadRow),
+          "effect_agent_threads",
+          request.threadId,
+          threadRows,
         );
 
-        if (request.producerEpoch !== conversation.producer_epoch) {
+        if (request.producerEpoch !== thread.producer_epoch) {
           return yield* SqliteFenceRejected.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<Record<string, unknown>>`
           SELECT
-            conversation_id,
+            thread_id,
             batch_id,
             first_sequence,
             last_sequence,
@@ -575,31 +901,34 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
             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(
           Schema.Array(BatchRow),
           "effect_agent_canonical_batches",
-          `${request.conversationId}/${request.batchId}`,
+          `${request.threadId}/${request.batchId}`,
           batchRows,
         );
 
         if (batches.length > 1) {
           return yield* SqliteStorageCorruptionError.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) {
           const existing = batches[0];
+
           if (existing.batch_digest !== request.batchDigest) {
             return yield* SqliteAppendConflict.make({
               message: `Batch ${request.batchId} already exists with different canonical content.`,
               reason: "batch-digest",
             });
           }
+
           return RawAppendResult.make({
             firstSequence: existing.first_sequence,
             lastSequence: existing.last_sequence,
@@ -609,43 +938,45 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         }
 
         if (
-          request.expectedTailSequence !== conversation.tail_sequence ||
-          request.expectedTailDigest !== conversation.tail_digest
+          request.expectedTailSequence !== thread.tail_sequence ||
+          request.expectedTailDigest !== thread.tail_digest
         ) {
           return yield* SqliteAppendConflict.make({
             message:
               `Expected tail ${request.expectedTailSequence}/${request.expectedTailDigest} ` +
-              `but found ${conversation.tail_sequence}/${conversation.tail_digest}.`,
+              `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) {
+        if (thread.tail_sequence + request.records.length > MAX_RECORDS_PER_THREAD) {
           return yield* SqliteStorageError.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 existingRecordRows = yield* sql<Record<string, unknown>>`
           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(recordIds)}
           ORDER BY sequence
         `.pipe(Effect.mapError(storageError("check canonical record identities")));
+
         const existingRecords = yield* decodeRows(
           Schema.Array(RecordRow),
           "effect_agent_canonical_records",
-          `${request.conversationId}/record_ids`,
+          `${request.threadId}/record_ids`,
           existingRecordRows,
         );
+
         if (existingRecords.length > 0) {
           return yield* SqliteAppendConflict.make({
             message: `Canonical record ID ${existingRecords[0].record_id} already exists.`,
@@ -654,7 +985,7 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         }
 
         const firstSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(
-          conversation.tail_sequence + 1,
+          thread.tail_sequence + 1,
         ).pipe(
           Effect.mapError((error) =>
             SqliteStorageError.make({
@@ -664,6 +995,7 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
             }),
           ),
         );
+
         const lastSequence = yield* Schema.decodeUnknownEffect(CanonicalSequence)(
           firstSequence + request.records.length - 1,
         ).pipe(
@@ -678,7 +1010,7 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
 
         yield* sql`
           INSERT INTO effect_agent_canonical_batches (
-            conversation_id,
+            thread_id,
             batch_id,
             first_sequence,
             last_sequence,
@@ -686,7 +1018,7 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
             tail_digest,
             batch_json
           ) VALUES (
-            ${request.conversationId},
+            ${request.threadId},
             ${request.batchId},
             ${firstSequence},
             ${lastSequence},
@@ -703,13 +1035,13 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
             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},
@@ -722,13 +1054,13 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         );
 
         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({
@@ -744,102 +1076,69 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
   const read = Effect.fn("SqliteJournal.read")(function* (request: RawReadRequest) {
     const rows = yield* sql<Record<string, unknown>>`
       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(
       Schema.Array(RecordRow),
       "effect_agent_canonical_records",
-      `${request.conversationId}>${request.fromSequenceExclusive}`,
+      `${request.threadId}>${request.fromSequenceExclusive}`,
       rows,
     );
   });
 
-  const exportConversation = Effect.fn("SqliteJournal.exportConversation")(function* (
-    conversationId: string,
-  ) {
+  const exportThread = Effect.fn("SqliteJournal.exportThread")(function* (threadId: string) {
     return yield* withReadTransaction("export transaction")(
       Effect.gen(function* () {
-        const conversationRows = yield* sql<Record<string, unknown>>`
+        const threadRows = yield* sql<Record<string, unknown>>`
             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,
+            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-conversation-read");
-        const batchRows = yield* sql<Record<string, unknown>>`
-            SELECT
-              conversation_id,
-              batch_id,
-              first_sequence,
-              last_sequence,
-              batch_digest,
-              tail_digest,
-              batch_json
-            FROM effect_agent_canonical_batches
-            WHERE conversation_id = ${conversationId}
-            ORDER BY first_sequence
-          `.pipe(Effect.mapError(storageError("export canonical batches")));
+
+        yield* failpoint("export:after-thread-read");
+
         const recordRows = yield* sql<Record<string, unknown>>`
             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<Record<string, unknown>>`
-            SELECT
-              conversation_id,
-              through_sequence,
-              tail_digest,
-              checkpoint_json
-            FROM effect_agent_checkpoints
-            WHERE conversation_id = ${conversationId}
-            ORDER BY through_sequence
-          `.pipe(Effect.mapError(storageError("export checkpoints")));
 
-        return RawConversationExport.make({
-          conversation,
-          batches: yield* decodeRows(
-            Schema.Array(BatchRow),
-            "effect_agent_canonical_batches",
-            conversationId,
-            batchRows,
-          ),
+        return RawThreadExport.make({
+          thread,
           records: yield* decodeRows(
             Schema.Array(RecordRow),
             "effect_agent_canonical_records",
-            conversationId,
+            threadId,
             recordRows,
           ),
-          checkpoints: yield* decodeRows(
-            Schema.Array(CheckpointRow),
-            "effect_agent_checkpoints",
-            conversationId,
-            checkpointRows,
-          ),
         });
       }),
     );
@@ -849,7 +1148,7 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
     checkpoint: RawCheckpoint,
   ): Effect.fn.Return<void, CheckpointError> {
     if (
-      checkpoint.conversationId.length > MAX_IDENTIFIER_LENGTH ||
+      checkpoint.threadId.length > MAX_IDENTIFIER_LENGTH ||
       storedTextBytes(checkpoint.checkpointJson) > MAX_STORED_TEXT_BYTES
     ) {
       return yield* SqliteStorageError.make({
@@ -859,50 +1158,54 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
     }
     yield* withWriteTransaction("checkpoint transaction")(
       Effect.gen(function* () {
-        const conversationRows = yield* sql<Record<string, unknown>>`
+        const threadRows = yield* sql<Record<string, unknown>>`
           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,
+
+        const thread = yield* decodeSingleRow(
+          Schema.Array(ThreadRow),
+          "effect_agent_threads",
+          checkpoint.threadId,
+          threadRows,
         );
-        if (checkpoint.throughSequence > conversation.tail_sequence) {
+
+        if (checkpoint.throughSequence > thread.tail_sequence) {
           return yield* SqliteCheckpointConflict.make({
             message:
               `Checkpoint sequence ${checkpoint.throughSequence} is after canonical tail ` +
-              `${conversation.tail_sequence}.`,
+              `${thread.tail_sequence}.`,
           });
         }
 
         const checkpointRows = yield* sql<Record<string, unknown>>`
           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(
           Schema.Array(CheckpointRow),
           "effect_agent_checkpoints",
-          `${checkpoint.conversationId}/${checkpoint.throughSequence}`,
+          `${checkpoint.threadId}/${checkpoint.throughSequence}`,
           checkpointRows,
         );
+
         if (existing.length > 1) {
           return yield* SqliteStorageCorruptionError.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.",
           });
         }
@@ -915,17 +1218,18 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
               message: "A different checkpoint already exists at this canonical sequence.",
             });
           }
+
           return;
         }
 
         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}
@@ -936,44 +1240,47 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
   });
 
   const loadCheckpoint = Effect.fn("SqliteJournal.loadCheckpoint")(function* (
-    conversationId: string,
+    threadId: string,
     atOrBeforeSequence: CanonicalSequence,
   ) {
     const rows = yield* sql<Record<string, unknown>>`
       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(
       Schema.Array(CheckpointRow),
       "effect_agent_checkpoints",
-      `${conversationId}<=${atOrBeforeSequence}`,
+      `${threadId}<=${atOrBeforeSequence}`,
       rows,
     );
   });
 
   const getTailDigestAt = Effect.fn("SqliteJournal.getTailDigestAt")(function* (
-    conversationId: string,
+    threadId: string,
     sequence: CanonicalSequence,
   ) {
     if (sequence === 0) {
-      const conversations = yield* getConversation(conversationId);
-      return conversations.length === 0
+      const threads = yield* getThread(threadId);
+
+      return threads.length === 0
         ? []
-        : [conversations[0].tail_sequence === 0 ? conversations[0].tail_digest : undefined].filter(
+        : [threads[0].tail_sequence === 0 ? threads[0].tail_digest : undefined].filter(
             (value): value is string => value !== undefined,
           );
     }
+
     const rows = yield* sql<Record<string, unknown>>`
       SELECT
-        conversation_id,
+        thread_id,
         batch_id,
         first_sequence,
         last_sequence,
@@ -981,34 +1288,37 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
         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")));
+
     const batches = yield* decodeRows(
       Schema.Array(BatchRow),
       "effect_agent_canonical_batches",
-      `${conversationId}/${sequence}`,
+      `${threadId}/${sequence}`,
       rows,
     );
+
     return batches.map((batch) => batch.tail_digest);
   });
 
   const scanStoredPayloads = Effect.fn("SqliteJournal.scanStoredPayloads")(function* () {
     return yield* withReadTransaction("startup scan transaction")(
       Effect.gen(function* () {
-        const conversations = yield* sql<Record<string, unknown>>`
+        const threads = yield* sql<Record<string, unknown>>`
             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<Record<string, unknown>>`
             SELECT
-              conversation_id,
+              thread_id,
               batch_id,
               first_sequence,
               last_sequence,
@@ -1016,33 +1326,36 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
               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<Record<string, unknown>>`
             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<Record<string, unknown>>`
             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(
-            Schema.Array(ConversationRow),
-            "effect_agent_conversations",
+          threads: yield* decodeRows(
+            Schema.Array(ThreadRow),
+            "effect_agent_threads",
             "startup_scan",
-            conversations,
+            threads,
           ),
           batches: yield* decodeRows(
             Schema.Array(BatchRow),
@@ -1069,8 +1382,8 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
 
   return {
     append,
-    exportConversation,
-    getConversation,
+    exportThread,
+    getThread,
     getTailDigestAt,
     loadCheckpoint,
     materialize,
@@ -1078,9 +1391,8 @@ const makeJournal = (sql: SqlClient.SqlClient, failpoint: SqliteJournalFailpoint
     saveCheckpoint,
     scanStoredPayloads,
     withWriteTransaction,
+    withReadTransaction,
   } as const;
-};
-
-export type SqliteJournal = ReturnType<typeof makeJournal>;
+});
 
-export const initializeSqliteJournal = ensureCurrentStorage;
+export type SqliteJournal = Effect.Success<ReturnType<typeof initializeSqliteJournal>>;