@effect-agent/storage-sqlite 0.1.0-beta.37 → 0.1.0-beta.39

package/dist/sqlite-storage-failpoint-Cr0SXflP.d.mts

@@ -0,0 +1,95 @@
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/errors.d.ts
+declare const SqliteStorageCompatibilityError_base: Schema.Class<SqliteStorageCompatibilityError, Schema.TaggedStruct<"SqliteStorageCompatibilityError", {
+  readonly actualVersion: Schema.Int;
+  readonly message: Schema.String;
+  readonly supportedVersion: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** The SQLite file uses a private-development format this adapter cannot read. */
+declare class SqliteStorageCompatibilityError extends SqliteStorageCompatibilityError_base {}
+declare const SqliteStorageCorruptionError_base: Schema.Class<SqliteStorageCorruptionError, Schema.TaggedStruct<"SqliteStorageCorruptionError", {
+  readonly message: Schema.String;
+  readonly rowKey: Schema.String;
+  readonly table: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Stored bytes failed the current Schema and cannot be used as recovery truth. */
+declare class SqliteStorageCorruptionError extends SqliteStorageCorruptionError_base {}
+declare const SqliteStorageError_base: Schema.Class<SqliteStorageError, Schema.TaggedStruct<"SqliteStorageError", {
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+  readonly message: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** SQLite infrastructure failed while opening or operating the store. */
+declare class SqliteStorageError extends SqliteStorageError_base {}
+declare const SqliteLedgerError_base: Schema.Class<SqliteLedgerError, Schema.TaggedStruct<"SqliteLedgerError", {
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+  readonly message: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * SQLite infrastructure failed while operating the Submission Ledger. Surfaces at the
+ * SubmissionLedger port as the typed `LedgerError` with this error preserved as its cause,
+ * so the adapter-level tag is never erased.
+ */
+declare class SqliteLedgerError extends SqliteLedgerError_base {}
+declare const SqliteAppendConflict_base: Schema.Class<SqliteAppendConflict, Schema.TaggedStruct<"SqliteAppendConflict", {
+  readonly message: Schema.String;
+  readonly reason: Schema.Literals<readonly ["batch-digest", "record-identity", "tail"]>;
+  readonly actualTailSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+  readonly actualTailDigest: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A canonical batch retry conflicts with existing append state. Tail conflicts carry the
+ * actual committed tail as a diagnostic resume hint.
+ */
+declare class SqliteAppendConflict extends SqliteAppendConflict_base {}
+declare const SqliteFenceRejected_base: Schema.Class<SqliteFenceRejected, Schema.TaggedStruct<"SqliteFenceRejected", {
+  readonly actualEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly message: Schema.String;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A producer epoch does not match the Thread's current writer registration. Appends
+ * require the exact registered epoch, so both older and newer unregistered epochs are fenced;
+ * a newer epoch takes over by materializing first.
+ */
+declare class SqliteFenceRejected extends SqliteFenceRejected_base {}
+declare const SqliteWriteContention_base: Schema.Class<SqliteWriteContention, Schema.TaggedStruct<"SqliteWriteContention", {
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+  readonly message: Schema.String;
+  readonly operation: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A write transaction could not acquire the SQLite write lock within the configured busy
+ * timeout (SQLITE_BUSY / SQLITE_LOCKED). Another transiently coexisting owner is writing;
+ * the operation did not mutate canonical state and is safe to retry.
+ */
+declare class SqliteWriteContention extends SqliteWriteContention_base {}
+declare const SqliteCheckpointConflict_base: Schema.Class<SqliteCheckpointConflict, Schema.TaggedStruct<"SqliteCheckpointConflict", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A checkpoint conflicts with a previously stored checkpoint at the same offset. */
+declare class SqliteCheckpointConflict extends SqliteCheckpointConflict_base {}
+declare const SqliteStorageFailpointLocation: Schema.Literals<readonly ["materialize:before", "materialize:after", "append:before", "append:after-batch-insert", "append:after-record-insert", "append:after-tail-update", "append:after", "export:after-thread-read", "save-checkpoint:before", "save-checkpoint:after", "ledger:admit:before", "ledger:admit:after", "ledger:mark-ready:before", "ledger:mark-ready:after", "ledger:claim:before", "ledger:claim:after", "ledger:mark-input-applied:before", "ledger:mark-input-applied:after", "ledger:renew:before", "ledger:renew:after", "ledger:reserve-settlement:before", "ledger:reserve-settlement:after", "ledger:finalize-settlement:before", "ledger:finalize-settlement:after", "ledger:request-abort:before", "ledger:request-abort:after", "ledger:release:before", "ledger:release:after", "ledger:claim-joining:before", "ledger:claim-joining:after", "ledger:mark-joined:before", "ledger:mark-joined:after", "ledger:revert-joining:before", "ledger:revert-joining:after", "ledger:suspend:before", "ledger:suspend:after", "ledger:approval-decision:before", "ledger:approval-decision:after", "ledger:mark-unknown:before", "ledger:mark-unknown:after", "ledger:unknown-resolution:before", "ledger:unknown-resolution:after", "ledger:child-reservation:before", "ledger:child-reservation:after", "ledger:child-attach:before", "ledger:child-attach:after", "ledger:child-release-pending:before", "ledger:child-release-pending:after", "ledger:child-release:before", "ledger:child-release:after", "ledger:child-settled:before", "ledger:child-settled:after"]>;
+type SqliteStorageFailpointLocation = typeof SqliteStorageFailpointLocation.Type;
+declare const SqliteStorageFailpointError_base: Schema.Class<SqliteStorageFailpointError, Schema.TaggedStruct<"SqliteStorageFailpointError", {
+  readonly location: Schema.Literals<readonly ["materialize:before", "materialize:after", "append:before", "append:after-batch-insert", "append:after-record-insert", "append:after-tail-update", "append:after", "export:after-thread-read", "save-checkpoint:before", "save-checkpoint:after", "ledger:admit:before", "ledger:admit:after", "ledger:mark-ready:before", "ledger:mark-ready:after", "ledger:claim:before", "ledger:claim:after", "ledger:mark-input-applied:before", "ledger:mark-input-applied:after", "ledger:renew:before", "ledger:renew:after", "ledger:reserve-settlement:before", "ledger:reserve-settlement:after", "ledger:finalize-settlement:before", "ledger:finalize-settlement:after", "ledger:request-abort:before", "ledger:request-abort:after", "ledger:release:before", "ledger:release:after", "ledger:claim-joining:before", "ledger:claim-joining:after", "ledger:mark-joined:before", "ledger:mark-joined:after", "ledger:revert-joining:before", "ledger:revert-joining:after", "ledger:suspend:before", "ledger:suspend:after", "ledger:approval-decision:before", "ledger:approval-decision:after", "ledger:mark-unknown:before", "ledger:mark-unknown:after", "ledger:unknown-resolution:before", "ledger:unknown-resolution:after", "ledger:child-reservation:before", "ledger:child-reservation:after", "ledger:child-attach:before", "ledger:child-attach:after", "ledger:child-release-pending:before", "ledger:child-release-pending:after", "ledger:child-release:before", "ledger:child-release:after", "ledger:child-settled:before", "ledger:child-settled:after"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Deterministic test-only fault or pause injected at a SQLite operation boundary. */
+declare class SqliteStorageFailpointError extends SqliteStorageFailpointError_base {
+  get message(): string;
+}
+//#endregion
+//#region src/sqlite-storage-failpoint.d.ts
+type SqliteStorageFailpointHandler = (location: SqliteStorageFailpointLocation) => Effect.Effect<void, SqliteStorageFailpointError>;
+declare const SqliteStorageFailpoint_base: Context.ServiceClass<SqliteStorageFailpoint, "@effect-agent/storage-sqlite/SqliteStorageFailpoint", {
+  readonly hit: SqliteStorageFailpointHandler;
+}>;
+/** Explicit fault-injection authority used at SQLite operation boundaries. */
+declare class SqliteStorageFailpoint extends SqliteStorageFailpoint_base {
+  /** Production default: no fault injection. */
+  static readonly layer: Layer.Layer<SqliteStorageFailpoint, never, never>;
+}
+//#endregion
+export { SqliteFenceRejected as a, SqliteStorageCorruptionError as c, SqliteStorageFailpointLocation as d, SqliteWriteContention as f, SqliteCheckpointConflict as i, SqliteStorageError as l, SqliteStorageFailpointHandler as n, SqliteLedgerError as o, SqliteAppendConflict as r, SqliteStorageCompatibilityError as s, SqliteStorageFailpoint as t, SqliteStorageFailpointError as u };
+//# sourceMappingURL=sqlite-storage-failpoint-Cr0SXflP.d.mts.map

package/dist/sqlite-storage-failpoint-DIwWk5dw.mjs

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from "effect";
+//#region src/sqlite-storage-failpoint.ts
+const noFailpoint = () => Effect.void;
+/** Explicit fault-injection authority used at SQLite operation boundaries. */
+var SqliteStorageFailpoint = class extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpoint") {
+	/** Production default: no fault injection. */
+	static layer = Layer.succeed(this)({ hit: noFailpoint });
+};
+//#endregion
+export { SqliteStorageFailpoint as t };
+
+//# sourceMappingURL=sqlite-storage-failpoint-DIwWk5dw.mjs.map

package/dist/sqlite-storage-failpoint-DIwWk5dw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-storage-failpoint-DIwWk5dw.mjs","names":[],"sources":["../src/sqlite-storage-failpoint.ts"],"sourcesContent":["import { Context, Effect, Layer } from \"effect\";\n\nimport type { SqliteStorageFailpointError, SqliteStorageFailpointLocation } from \"./errors.ts\";\n\nexport type SqliteStorageFailpointHandler = (\n  location: SqliteStorageFailpointLocation,\n) => Effect.Effect<void, SqliteStorageFailpointError>;\n\nconst noFailpoint: SqliteStorageFailpointHandler = () => Effect.void;\n\n/** Explicit fault-injection authority used at SQLite operation boundaries. */\nexport class SqliteStorageFailpoint extends Context.Service<\n  SqliteStorageFailpoint,\n  {\n    readonly hit: SqliteStorageFailpointHandler;\n  }\n>()(\"@effect-agent/storage-sqlite/SqliteStorageFailpoint\") {\n  /** Production default: no fault injection. */\n  static readonly layer = Layer.succeed(this)({ hit: noFailpoint });\n}\n"],"mappings":";;AAQA,MAAM,oBAAmD,OAAO;;AAGhE,IAAa,yBAAb,cAA4C,QAAQ,QAKlD,CAAC,CAAC,qDAAqD,CAAC,CAAC;;CAEzD,OAAgB,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC,EAAE,KAAK,YAAY,CAAC;AAClE"}

package/dist/testing.d.mts

@@ -0,0 +1,15 @@
+import { n as SqliteStorageFailpointHandler, t as SqliteStorageFailpoint } from "./sqlite-storage-failpoint-Cr0SXflP.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/sqlite-storage-failpoint-testing.d.ts
+declare const SqliteStorageFailpointTestControl_base: Context.ServiceClass<SqliteStorageFailpointTestControl, "@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl", {
+  readonly clear: Effect.Effect<void>;
+  readonly setHandler: (handler: SqliteStorageFailpointHandler) => Effect.Effect<void>;
+}>;
+/** Test-only control for replacing the active SQLite failpoint handler. */
+declare class SqliteStorageFailpointTestControl extends SqliteStorageFailpointTestControl_base {
+  /** Reusable test Layer with a control service backed by the same handler Ref. */
+  static readonly layer: Layer.Layer<SqliteStorageFailpoint | SqliteStorageFailpointTestControl, never, never>;
+}
+//#endregion
+export { SqliteStorageFailpointTestControl };
+//# sourceMappingURL=testing.d.mts.map

package/dist/testing.mjs

@@ -0,0 +1,19 @@
+import { t as SqliteStorageFailpoint } from "./sqlite-storage-failpoint-DIwWk5dw.mjs";
+import { Context, Effect, Layer, Ref } from "effect";
+//#region src/sqlite-storage-failpoint-testing.ts
+const noFailpoint = () => Effect.void;
+/** Test-only control for replacing the active SQLite failpoint handler. */
+var SqliteStorageFailpointTestControl = class SqliteStorageFailpointTestControl extends Context.Service()("@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl") {
+	/** Reusable test Layer with a control service backed by the same handler Ref. */
+	static layer = Layer.effectContext(Effect.gen(function* () {
+		const handler = yield* Ref.make(noFailpoint);
+		return Context.make(SqliteStorageFailpoint, SqliteStorageFailpoint.of({ hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))) })).pipe(Context.add(SqliteStorageFailpointTestControl, SqliteStorageFailpointTestControl.of({
+			clear: Ref.set(handler, noFailpoint),
+			setHandler: (next) => Ref.set(handler, next)
+		})));
+	}));
+};
+//#endregion
+export { SqliteStorageFailpointTestControl };
+
+//# sourceMappingURL=testing.mjs.map

package/dist/testing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.mjs","names":[],"sources":["../src/sqlite-storage-failpoint-testing.ts"],"sourcesContent":["import { Context, Effect, Layer, Ref } from \"effect\";\n\nimport {\n  SqliteStorageFailpoint,\n  type SqliteStorageFailpointHandler,\n} from \"./sqlite-storage-failpoint.ts\";\n\nconst noFailpoint: SqliteStorageFailpointHandler = () => Effect.void;\n\n/** Test-only control for replacing the active SQLite failpoint handler. */\nexport class SqliteStorageFailpointTestControl extends Context.Service<\n  SqliteStorageFailpointTestControl,\n  {\n    readonly clear: Effect.Effect<void>;\n    readonly setHandler: (handler: SqliteStorageFailpointHandler) => Effect.Effect<void>;\n  }\n>()(\"@effect-agent/storage-sqlite/SqliteStorageFailpointTestControl\") {\n  /** Reusable test Layer with a control service backed by the same handler Ref. */\n  static readonly layer = Layer.effectContext(\n    Effect.gen(function* () {\n      const handler = yield* Ref.make<SqliteStorageFailpointHandler>(noFailpoint);\n      return Context.make(\n        SqliteStorageFailpoint,\n        SqliteStorageFailpoint.of({\n          hit: (location) => Ref.get(handler).pipe(Effect.flatMap((current) => current(location))),\n        }),\n      ).pipe(\n        Context.add(\n          SqliteStorageFailpointTestControl,\n          SqliteStorageFailpointTestControl.of({\n            clear: Ref.set(handler, noFailpoint),\n            setHandler: (next) => Ref.set(handler, next),\n          }),\n        ),\n      );\n    }),\n  );\n}\n"],"mappings":";;;AAOA,MAAM,oBAAmD,OAAO;;AAGhE,IAAa,oCAAb,MAAa,0CAA0C,QAAQ,QAM7D,CAAC,CAAC,gEAAgE,CAAC,CAAC;;CAEpE,OAAgB,QAAQ,MAAM,cAC5B,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,IAAI,KAAoC,WAAW;EAC1E,OAAO,QAAQ,KACb,wBACA,uBAAuB,GAAG,EACxB,MAAM,aAAa,IAAI,IAAI,OAAO,CAAC,CAAC,KAAK,OAAO,SAAS,YAAY,QAAQ,QAAQ,CAAC,CAAC,EACzF,CAAC,CACH,CAAC,CAAC,KACA,QAAQ,IACN,mCACA,kCAAkC,GAAG;GACnC,OAAO,IAAI,IAAI,SAAS,WAAW;GACnC,aAAa,SAAS,IAAI,IAAI,SAAS,IAAI;EAC7C,CAAC,CACH,CACF;CACF,CAAC,CACH;AACF"}

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@effect-agent/storage-sqlite",
-  "version": "0.1.0-beta.37",
+  "version": "0.1.0-beta.39",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.mts",
+      "default": "./dist/testing.mjs"
     }
   },
   "dependencies": {
-    "@effect-agent/session": "0.1.0-beta.37",
+    "@effect-agent/thread": "0.1.0-beta.39",
     "@effect/platform-node": "4.0.0-rc.111",
-    "@effect/sql-sqlite-node": "4.0.0-rc.111",
-    "effect": "4.0.0-rc.111"
+    "@effect/sql-sqlite-node": "4.0.0-rc.111"
   },
-  "description": "Node SQLite Conversation store and submission ledger adapters for the Effect Agent durable runtime.",
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.111"
+  },
+  "description": "Node SQLite Thread store and submission ledger adapters for the Effect Agent durable runtime.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -35,6 +41,7 @@
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.111",
+    "effect": "4.0.0-rc.111",
     "typescript": "7.0.2",
     "vite-plus": "0.2.6"
   }

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { CanonicalSequence, ProducerEpoch } from "@effect-agent/session";
+import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread";
 import { Schema } from "effect";
 
 /** The SQLite file uses a private-development format this adapter cannot read. */
@@ -60,7 +60,7 @@ export class SqliteAppendConflict extends Schema.TaggedError<SqliteAppendConflic
 ) {}
 
 /**
- * A producer epoch does not match the Conversation's current writer registration. Appends
+ * A producer epoch does not match the Thread's current writer registration. Appends
  * require the exact registered epoch, so both older and newer unregistered epochs are fenced;
  * a newer epoch takes over by materializing first.
  */
@@ -103,7 +103,7 @@ export const SqliteStorageFailpointLocation = Schema.Literals([
   "append:after-record-insert",
   "append:after-tail-update",
   "append:after",
-  "export:after-conversation-read",
+  "export:after-thread-read",
   "save-checkpoint:before",
   "save-checkpoint:after",
   "ledger:admit:before",

package/src/index.ts

@@ -1,7 +1,8 @@
 export * from "./errors.ts";
-export * from "./migrations.ts";
-export * from "./sqlite-conversation-store.ts";
+export { CurrentSqliteStorageVersion } from "./migrations.ts";
+export * from "./sqlite-thread-store.ts";
 export * from "./sqlite-ledger.ts";
 export * from "./sqlite-schedule-store.ts";
+export * from "./sqlite-subscription-store.ts";
 export * from "./sqlite-storage-config.ts";
 export * from "./sqlite-storage-failpoint.ts";

package/src/migrations.ts

@@ -2,15 +2,15 @@ import { SqliteMigrator } from "@effect/sql-sqlite-node";
 import { Effect } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
-export const CurrentSqliteStorageVersion = 5;
+export const CurrentSqliteStorageVersion = 7;
 
 export const sqliteMigrations = SqliteMigrator.fromRecord({
-  "1_current_persistent_conversation_foundation": Effect.gen(function* () {
+  "1_current_persistent_thread_foundation": Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
 
     yield* sql`
-      CREATE TABLE effect_agent_conversations (
-        conversation_id TEXT PRIMARY KEY NOT NULL,
+      CREATE TABLE effect_agent_threads (
+        thread_id TEXT PRIMARY KEY NOT NULL,
         created_at TEXT NOT NULL,
         tail_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
@@ -20,49 +20,49 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_batches (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         first_sequence INTEGER NOT NULL,
         last_sequence INTEGER NOT NULL,
         batch_digest TEXT NOT NULL,
         tail_digest TEXT NOT NULL,
         batch_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, batch_id),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, batch_id),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_canonical_records (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         sequence INTEGER NOT NULL,
         record_id TEXT NOT NULL,
         batch_id TEXT NOT NULL,
         record_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, sequence),
-        UNIQUE (conversation_id, record_id),
-        FOREIGN KEY (conversation_id, batch_id)
-          REFERENCES effect_agent_canonical_batches(conversation_id, batch_id)
+        PRIMARY KEY (thread_id, sequence),
+        UNIQUE (thread_id, record_id),
+        FOREIGN KEY (thread_id, batch_id)
+          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
 
     yield* sql`
       CREATE INDEX effect_agent_canonical_records_batch
-        ON effect_agent_canonical_records (conversation_id, batch_id, sequence)
+        ON effect_agent_canonical_records (thread_id, batch_id, sequence)
     `.withoutTransform;
 
     yield* sql`
       CREATE TABLE effect_agent_checkpoints (
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         through_sequence INTEGER NOT NULL,
         tail_digest TEXT NOT NULL,
         checkpoint_json TEXT NOT NULL,
-        PRIMARY KEY (conversation_id, through_sequence),
-        FOREIGN KEY (conversation_id)
-          REFERENCES effect_agent_conversations(conversation_id)
+        PRIMARY KEY (thread_id, through_sequence),
+        FOREIGN KEY (thread_id)
+          REFERENCES effect_agent_threads(thread_id)
           ON DELETE RESTRICT
       )
     `.withoutTransform;
@@ -72,12 +72,12 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
   "2_durable_submission_ledger": Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
 
-    // Admission rows exist before Conversation materialization (durability §4), so
-    // conversation_id intentionally carries no foreign key into effect_agent_conversations.
+    // Admission rows exist before Thread materialization (durability §4), so
+    // thread_id intentionally carries no foreign key into effect_agent_threads.
     yield* sql`
       CREATE TABLE effect_agent_submissions (
         submission_id TEXT PRIMARY KEY NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         queue_sequence INTEGER NOT NULL,
         principal TEXT NOT NULL,
         idempotency_key TEXT NOT NULL,
@@ -93,8 +93,8 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
         ready_at TEXT,
         input_applied_record_id TEXT,
         input_applied_sequence INTEGER,
-        UNIQUE (conversation_id, principal, idempotency_key),
-        UNIQUE (conversation_id, queue_sequence)
+        UNIQUE (thread_id, principal, idempotency_key),
+        UNIQUE (thread_id, queue_sequence)
       )
     `.withoutTransform;
 
@@ -116,7 +116,7 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
       CREATE TABLE effect_agent_attempts (
         attempt_id TEXT PRIMARY KEY NOT NULL,
         submission_id TEXT NOT NULL,
-        conversation_id TEXT NOT NULL,
+        thread_id TEXT NOT NULL,
         owner_producer_id TEXT NOT NULL,
         producer_epoch INTEGER NOT NULL,
         claimed_at TEXT NOT NULL,
@@ -302,4 +302,85 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
 
     yield* sql`PRAGMA user_version = 5`.withoutTransform;
   }),
+  "6_durable_subscriptions": Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql`
+      CREATE TABLE effect_agent_subscription_sequences (
+        tenant_id TEXT NOT NULL,
+        source_address TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        event_scan_cursor TEXT NOT NULL,
+        delivery_scan_cursor TEXT NOT NULL,
+        recovery_scan_cursor INTEGER NOT NULL,
+        PRIMARY KEY (tenant_id, source_address)
+      )
+    `.withoutTransform;
+    yield* sql`
+      CREATE TABLE effect_agent_subscriptions (
+        tenant_id TEXT NOT NULL,
+        source_address TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        subscription_id TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        source_name TEXT NOT NULL,
+        source_version TEXT NOT NULL,
+        matching_key TEXT NOT NULL,
+        state TEXT NOT NULL,
+        expires_at_millis INTEGER NOT NULL,
+        recovery_at_millis INTEGER,
+        record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id),
+        UNIQUE (tenant_id, source_address, ordinal)
+      )
+    `.withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscriptions_owner ON effect_agent_subscriptions (tenant_id, source_address, owner_id, ordinal)`
+      .withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscriptions_candidates ON effect_agent_subscriptions (tenant_id, source_address, source_name, source_version, matching_key, ordinal)`
+      .withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscriptions_recovery ON effect_agent_subscriptions (tenant_id, source_address, recovery_at_millis, ordinal) WHERE recovery_at_millis IS NOT NULL`
+      .withoutTransform;
+    yield* sql`
+      CREATE TABLE effect_agent_subscription_events (
+        tenant_id TEXT NOT NULL,
+        source_address TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        source_name TEXT NOT NULL,
+        source_version TEXT NOT NULL,
+        matching_key TEXT NOT NULL,
+        payload_digest TEXT NOT NULL,
+        cutoff INTEGER NOT NULL,
+        cursor INTEGER NOT NULL,
+        routing_complete INTEGER NOT NULL,
+        next_attempt_at_millis INTEGER NOT NULL,
+        record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, source_address, event_id)
+      )
+    `.withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscription_events_pending ON effect_agent_subscription_events (tenant_id, source_address, routing_complete, next_attempt_at_millis, event_id)`
+      .withoutTransform;
+    yield* sql`
+      CREATE TABLE effect_agent_subscription_deliveries (
+        tenant_id TEXT NOT NULL,
+        source_address TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        subscription_id TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        delivery_key TEXT NOT NULL,
+        state TEXT NOT NULL,
+        next_attempt_at_millis INTEGER NOT NULL,
+        record_json TEXT NOT NULL,
+        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id, event_id),
+        UNIQUE (tenant_id, source_address, delivery_key)
+      )
+    `.withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscription_deliveries_pending ON effect_agent_subscription_deliveries (tenant_id, source_address, state, next_attempt_at_millis, delivery_key)`
+      .withoutTransform;
+    yield* sql`CREATE INDEX effect_agent_subscription_deliveries_registration ON effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, delivery_key)`
+      .withoutTransform;
+    yield* sql`PRAGMA user_version = 6`.withoutTransform;
+  }),
+  "7_thread_terminology_cutover": Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql`PRAGMA user_version = 7`.withoutTransform;
+  }),
 });