@effect-agent/storage-sqlite 0.1.0-beta.63 → 0.1.0-beta.65

package/src/SqliteThreadStore.ts

@@ -28,6 +28,9 @@ import {
   FencedAppendRequest,
   LoadCheckpointRequest,
   SaveCheckpointRequest,
+  SaveRecoveryCheckpointRequest,
+  MAX_THREAD_EXPORT_RECORDS,
+  type ThreadRecoveryCheckpoints,
 } from "@effect-agent/thread/ThreadStore";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
@@ -292,9 +295,9 @@ const groupByKey = <A>(
 };
 
 /**
- * Opt-in full integrity audit (`verifyOnOpen`). Every stored payload is decoded, re-encoded,
- * 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.
+ * Opt-in integrity audit (`verifyOnOpen`) of canonical payloads, their digest chains and generic
+ * projection checkpoints. Disposable recovery checkpoints are validated when loaded. Routine opens
+ * skip this scan: per-operation Schema decoding fails clearly on corrupt canonical rows.
  */
 const decodeStartupPayloads = Effect.fn("SqliteThreadStore.decodeStartupPayloads")(function* (
   journal: SqliteJournal,
@@ -687,7 +690,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
 
       const records = yield* Effect.forEach(exported.records, decodeEnvelope);
 
-      if (records.length > 65_536) {
+      if (records.length > MAX_THREAD_EXPORT_RECORDS) {
         return yield* ThreadStoreError.make({
           operation: "decode thread export",
           message: "The thread exceeds the current export record limit.",
@@ -831,6 +834,92 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
     },
   );
 
+  const saveRecoveryCheckpoint: ThreadRecoveryCheckpoints["save"] = Effect.fn(
+    "SqliteThreadStore.saveRecoveryCheckpoint",
+  )(function* (request) {
+    const validated = yield* Schema.decodeUnknownEffect(
+      Schema.toType(SaveRecoveryCheckpointRequest),
+    )(request).pipe(
+      Effect.mapError((error) => schemaStoreError("validate recovery checkpoint", error)),
+    );
+
+    const checkpointJson = yield* encodeCheckpoint(validated.checkpoint);
+
+    yield* journal
+      .saveRecoveryCheckpoint(validated, checkpointJson)
+      .pipe(
+        Effect.mapError((error) =>
+          error._tag === "CheckpointRejected" ||
+          error._tag === "FenceRejected" ||
+          error._tag === "ThreadNotMaterialized"
+            ? error
+            : storeError("save recovery checkpoint", error),
+        ),
+      );
+  });
+
+  const loadRecoveryCheckpoint: ThreadRecoveryCheckpoints["load"] = Effect.fn(
+    "SqliteThreadStore.loadRecoveryCheckpoint",
+  )(function* (request) {
+    const validated = yield* Schema.decodeUnknownEffect(Schema.toType(LoadCheckpointRequest))(
+      request,
+    ).pipe(
+      Effect.mapError((error) => schemaStoreError("validate recovery checkpoint lookup", error)),
+    );
+
+    const thread = yield* requireThread(journal, validated.threadId);
+
+    const corrupt = () =>
+      CheckpointRejected.make({ threadId: validated.threadId, reason: "corrupt" });
+
+    const rows = yield* journal
+      .loadRecoveryCheckpoint(validated.threadId)
+      .pipe(
+        Effect.mapError((error) =>
+          error._tag === "SqliteStorageCorruptionError"
+            ? corrupt()
+            : storeError("load recovery checkpoint", error),
+        ),
+      );
+
+    if (rows.length === 0) return Option.none();
+    if (rows.length !== 1) return yield* corrupt();
+    const row = rows[0];
+
+    const checkpoint = yield* Schema.decodeEffect(Schema.fromJsonString(ThreadCheckpoint))(
+      row.checkpoint_json,
+    ).pipe(Effect.mapError(corrupt));
+
+    if (
+      row.thread_id !== validated.threadId ||
+      checkpoint.threadId !== row.thread_id ||
+      checkpoint.throughSequence !== row.through_sequence ||
+      checkpoint.tailDigest !== row.tail_digest
+    )
+      return yield* corrupt();
+    if (checkpoint.throughSequence > thread.tail_sequence)
+      return yield* CheckpointRejected.make({
+        threadId: validated.threadId,
+        reason: "ahead-of-tail",
+      });
+    if (checkpoint.throughSequence > (validated.atOrBeforeSequence ?? thread.tail_sequence))
+      return Option.none();
+
+    const canonicalDigest = yield* tailDigestAt(
+      journal,
+      checkpoint.threadId,
+      checkpoint.throughSequence,
+    );
+
+    if (canonicalDigest !== checkpoint.tailDigest)
+      return yield* CheckpointRejected.make({
+        threadId: validated.threadId,
+        reason: "digest-mismatch",
+      });
+
+    return Option.some(checkpoint);
+  });
+
   const threadStore = ThreadStore.of({
     append,
     export: exportThread,
@@ -839,6 +928,7 @@ const makeServices = Effect.fn("SqliteThreadStore.makeServices")(function* () {
     observe,
     read,
     checkpoints: { save: saveCheckpoint, load: loadCheckpoint },
+    recoveryCheckpoints: { save: saveRecoveryCheckpoint, load: loadRecoveryCheckpoint },
   });
 
   return Context.make(ThreadStore, threadStore);

package/src/internal/migrations.ts

@@ -3,8 +3,9 @@ import { Effect } from "effect";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 
 import { createMessageDeliveryTables } from "./message-delivery-schema.ts";
+import { createRecoveryCheckpointTable } from "./recovery-checkpoint-schema.ts";
 
-export const CurrentSqliteStorageVersion = 9;
+export const CurrentSqliteStorageVersion = 10;
 
 /** Initialize empty storage with the complete current schema. */
 export const sqliteMigrations = SqliteMigrator.fromRecord({
@@ -336,6 +337,7 @@ export const sqliteMigrations = SqliteMigrator.fromRecord({
     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* createMessageDeliveryTables;
-    yield* sql`PRAGMA user_version = 9`.withoutTransform;
+    yield* createRecoveryCheckpointTable;
+    yield* sql`PRAGMA user_version = 10`.withoutTransform;
   }),
 });

package/src/internal/recovery-checkpoint-schema.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+/** One disposable recovery snapshot per Thread, independent of generic projections. */
+export const createRecoveryCheckpointTable = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`
+    CREATE TABLE effect_agent_recovery_checkpoints (
+      thread_id TEXT PRIMARY KEY NOT NULL,
+      through_sequence INTEGER NOT NULL,
+      tail_digest TEXT NOT NULL,
+      checkpoint_json TEXT NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES effect_agent_threads(thread_id) ON DELETE RESTRICT
+    )
+  `.withoutTransform;
+});

package/src/internal/sqlite-journal.ts

@@ -1,3 +1,4 @@
+import { EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
 import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread/Records";
 import { ScheduleFailpoint, ScheduleFailpointError } from "@effect-agent/thread/Schedule";
 import {
@@ -9,6 +10,13 @@ import {
   SubscriptionFailpoint,
   SubscriptionFailpointError,
 } from "@effect-agent/thread/Subscription";
+import {
+  MAX_THREAD_EXPORT_RECORDS,
+  CheckpointRejected,
+  FenceRejected,
+  ThreadNotMaterialized,
+  type SaveRecoveryCheckpointRequest,
+} from "@effect-agent/thread/ThreadStore";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteMigrator } from "@effect/sql-sqlite-node";
 import { Effect, Exit, Schema } from "effect";
@@ -30,11 +38,13 @@ import {
 import { SqliteStorageFailpoint } from "../SqliteStorageFailpoint.ts";
 import { createMessageDeliveryTables } from "./message-delivery-schema.ts";
 import { CurrentSqliteStorageVersion, sqliteMigrations } from "./migrations.ts";
+import { createRecoveryCheckpointTable } from "./recovery-checkpoint-schema.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_THREAD = 65_536;
+const MAX_RECORDS_PER_THREAD = MAX_THREAD_EXPORT_RECORDS;
+const ZERO_SEQUENCE = Schema.decodeSync(CanonicalSequence)(0);
 const MAX_STORED_TEXT_BYTES = 16 * 1024 * 1024;
 const MAX_IDENTIFIER_LENGTH = 1_024;
 
@@ -370,10 +380,32 @@ const predecessorColumns = {
   ],
 } as const;
 
-const checkPredecessorLayout = Effect.fn("SqliteJournal.checkPredecessorLayout")(function* () {
+const checkPredecessorLayout = Effect.fn("SqliteJournal.checkPredecessorLayout")(function* (
+  version: 8 | 9,
+) {
   const sql = yield* SqlClient.SqlClient;
 
-  for (const [table, expected] of Object.entries(predecessorColumns)) {
+  const expectedColumns =
+    version === 8
+      ? predecessorColumns
+      : {
+          ...predecessorColumns,
+          effect_agent_submissions: [
+            ...predecessorColumns.effect_agent_submissions,
+            "worker_admission_json",
+            "message_admission_json",
+          ],
+          effect_agent_message_deliveries: [
+            "owner_thread_id",
+            "message_id",
+            "version",
+            "state",
+            "deadline_at_millis",
+            "record_json",
+          ],
+        };
+
+  for (const [table, expected] of Object.entries(expectedColumns)) {
     const columns = yield* decodeRows(
       Schema.Array(Schema.Struct({ name: BoundedIdentifier })),
       table,
@@ -385,9 +417,9 @@ const checkPredecessorLayout = Effect.fn("SqliteJournal.checkPredecessorLayout")
 
     if (columns.length !== names.size || columns.some((column) => !names.has(column.name)))
       return yield* SqliteStorageCompatibilityError.make({
-        actualVersion: 8,
+        actualVersion: version,
         supportedVersion: CurrentSqliteStorageVersion,
-        message: `The v8 ${table} columns do not match the supported predecessor; no upgrade was committed.`,
+        message: `The v${version} ${table} columns do not match the supported predecessor; no upgrade was committed.`,
       });
   }
 });
@@ -439,6 +471,7 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
     version.user_version !== 0 &&
     version.user_version !== 7 &&
     version.user_version !== 8 &&
+    version.user_version !== 9 &&
     version.user_version !== CurrentSqliteStorageVersion
   ) {
     return yield* SqliteStorageCompatibilityError.make({
@@ -447,11 +480,11 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
       message:
         `The SQLite file uses unsupported storage version ${version.user_version}; ` +
         `this build supports exactly version ${CurrentSqliteStorageVersion}. ` +
-        "Only supported v7 and v8 can be upgraded automatically. Keep the original file and use a compatible library version.",
+        "Only supported v7, v8 and v9 can be upgraded automatically. Keep the original file and use a compatible library version.",
     });
   }
 
-  if (version.user_version === 7 || version.user_version === 8) {
+  if (version.user_version === 7 || version.user_version === 8 || version.user_version === 9) {
     yield* sql
       .withTransaction(
         Effect.gen(function* () {
@@ -461,7 +494,9 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
             return;
           if (
             current.length !== 1 ||
-            (current[0].user_version !== 7 && current[0].user_version !== 8)
+            (current[0].user_version !== 7 &&
+              current[0].user_version !== 8 &&
+              current[0].user_version !== 9)
           )
             return yield* SqliteStorageCompatibilityError.make({
               actualVersion: -1,
@@ -486,6 +521,16 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
                 "The predecessor store is missing required tables; no upgrade was committed.",
             });
 
+          const recoveryTables =
+            yield* sql`SELECT name FROM sqlite_master WHERE type='table' AND name='effect_agent_recovery_checkpoints'`;
+
+          if (recoveryTables.length !== 0)
+            return yield* SqliteStorageCompatibilityError.make({
+              actualVersion: current[0].user_version,
+              supportedVersion: CurrentSqliteStorageVersion,
+              message:
+                "The predecessor already contains recovery checkpoint storage; refusing ambiguous data without mutation.",
+            });
           if (current[0].user_version === 7) {
             yield* checkV2ThreadLayout();
             for (const statement of [
@@ -516,18 +561,24 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
               }),
             );
           }
-          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");
+          if (current[0].user_version === 8 || current[0].user_version === 9)
+            yield* checkPredecessorLayout(current[0].user_version);
+          if (current[0].user_version !== 9) {
+            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-mutation");
-          yield* createMessageDeliveryTables;
+          yield* createRecoveryCheckpointTable;
           yield* failpoint("upgrade:after-mutation");
           yield* failpoint("upgrade:before-version");
-          yield* sql`PRAGMA user_version = 9`;
+          yield* sql`PRAGMA user_version = 10`;
           yield* failpoint("upgrade:after-version");
         }),
       )
@@ -618,7 +669,8 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
         'effect_agent_approval_decisions',
         'effect_agent_unknown_resolutions',
         'effect_agent_schedules',
-        'effect_agent_message_deliveries'
+        'effect_agent_message_deliveries',
+        'effect_agent_recovery_checkpoints'
       )
     ORDER BY name
   `.pipe(Effect.mapError(storageError("verify storage tables")));
@@ -630,7 +682,7 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
     requiredRows,
   );
 
-  if (required.length !== 13) {
+  if (required.length !== 14) {
     return yield* SqliteStorageCompatibilityError.make({
       actualVersion: CurrentSqliteStorageVersion,
       supportedVersion: CurrentSqliteStorageVersion,
@@ -1119,27 +1171,52 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
 
         yield* failpoint("export:after-thread-read");
 
-        const recordRows = yield* sql<Record<string, unknown>>`
-            SELECT
-              thread_id,
-              sequence,
-              record_id,
-              batch_id,
-              record_json
-            FROM effect_agent_canonical_records
-            WHERE thread_id = ${threadId}
-            ORDER BY sequence
-          `.pipe(Effect.mapError(storageError("export canonical records")));
+        if (thread.tail_sequence > MAX_RECORDS_PER_THREAD)
+          return yield* SqliteStorageError.make({
+            operation: "export thread",
+            message: "The thread exceeds the current export record limit.",
+          });
+        const records: Array<RecordRow> = [];
+        let afterSequence = ZERO_SEQUENCE;
 
-        return RawThreadExport.make({
-          thread,
-          records: yield* decodeRows(
-            Schema.Array(RecordRow),
-            "effect_agent_canonical_records",
+        while (afterSequence < thread.tail_sequence) {
+          const limit = Math.min(1_024, thread.tail_sequence - afterSequence);
+
+          const request = RawReadRequest.make({
             threadId,
-            recordRows,
-          ),
-        });
+            fromSequenceExclusive: afterSequence,
+            limit,
+          });
+
+          const page = yield* read(request);
+
+          if (
+            page.length !== limit ||
+            page.some((record, index) => record.sequence !== afterSequence + index + 1)
+          ) {
+            return yield* SqliteStorageCorruptionError.make({
+              table: "effect_agent_canonical_records",
+              rowKey: threadId,
+              message: "The exported canonical prefix is not contiguous through its captured tail.",
+            });
+          }
+          records.push(...page);
+          afterSequence = page[page.length - 1].sequence;
+        }
+
+        const beyondTail =
+          yield* sql`SELECT sequence FROM effect_agent_canonical_records WHERE thread_id=${threadId} AND sequence > ${thread.tail_sequence} LIMIT 1`.pipe(
+            Effect.mapError(storageError("verify export tail")),
+          );
+
+        if (beyondTail.length !== 0)
+          return yield* SqliteStorageCorruptionError.make({
+            table: "effect_agent_canonical_records",
+            rowKey: threadId,
+            message: "Canonical records exist beyond the captured thread tail.",
+          });
+
+        return RawThreadExport.make({ thread, records });
       }),
     );
   });
@@ -1239,6 +1316,83 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
     );
   });
 
+  const saveRecoveryCheckpoint = Effect.fn("SqliteJournal.saveRecoveryCheckpoint")(function* (
+    request: SaveRecoveryCheckpointRequest,
+    checkpointJson: string,
+  ) {
+    const { checkpoint } = request;
+
+    if (
+      checkpoint.threadId.length > MAX_IDENTIFIER_LENGTH ||
+      storedTextBytes(checkpointJson) > MAX_STORED_TEXT_BYTES
+    ) {
+      return yield* SqliteStorageError.make({
+        operation: "save recovery checkpoint",
+        message: "Checkpoint identity or encoded JSON exceeds the SQLite storage bounds.",
+      });
+    }
+    yield* withWriteTransaction("recovery checkpoint transaction")(
+      Effect.gen(function* () {
+        const threads = yield* getThread(checkpoint.threadId);
+        const thread = threads[0];
+
+        if (thread === undefined)
+          return yield* ThreadNotMaterialized.make({ threadId: checkpoint.threadId });
+        if (request.producerEpoch !== thread.producer_epoch)
+          return yield* FenceRejected.make({
+            threadId: checkpoint.threadId,
+            actualEpoch: thread.producer_epoch,
+            attemptedEpoch: request.producerEpoch,
+          });
+        if (checkpoint.throughSequence > thread.tail_sequence)
+          return yield* CheckpointRejected.make({
+            threadId: checkpoint.threadId,
+            reason: "ahead-of-tail",
+          });
+
+        const digests =
+          checkpoint.throughSequence === 0
+            ? [EMPTY_TAIL_DIGEST]
+            : yield* getTailDigestAt(checkpoint.threadId, checkpoint.throughSequence);
+
+        if (digests.length !== 1 || digests[0] !== checkpoint.tailDigest)
+          return yield* CheckpointRejected.make({
+            threadId: checkpoint.threadId,
+            reason: "digest-mismatch",
+          });
+
+        yield* failpoint("save-recovery-checkpoint:before");
+        yield* sql`
+          INSERT INTO effect_agent_recovery_checkpoints (thread_id, through_sequence, tail_digest, checkpoint_json)
+          VALUES (${checkpoint.threadId}, ${checkpoint.throughSequence}, ${checkpoint.tailDigest}, ${checkpointJson})
+          ON CONFLICT (thread_id) DO UPDATE SET
+            through_sequence = excluded.through_sequence,
+            tail_digest = excluded.tail_digest,
+            checkpoint_json = excluded.checkpoint_json
+          WHERE excluded.through_sequence >= effect_agent_recovery_checkpoints.through_sequence
+        `.pipe(Effect.mapError(storageError("save recovery checkpoint")));
+      }),
+    );
+    yield* failpoint("save-recovery-checkpoint:after");
+  });
+
+  const loadRecoveryCheckpoint = Effect.fn("SqliteJournal.loadRecoveryCheckpoint")(function* (
+    threadId: string,
+  ) {
+    const rows = yield* sql<Record<string, unknown>>`
+      SELECT thread_id, through_sequence, tail_digest, checkpoint_json
+      FROM effect_agent_recovery_checkpoints
+      WHERE thread_id = ${threadId}
+    `.pipe(Effect.mapError(storageError("load recovery checkpoint")));
+
+    return yield* decodeRows(
+      Schema.Array(CheckpointRow),
+      "effect_agent_recovery_checkpoints",
+      threadId,
+      rows,
+    );
+  });
+
   const loadCheckpoint = Effect.fn("SqliteJournal.loadCheckpoint")(function* (
     threadId: string,
     atOrBeforeSequence: CanonicalSequence,
@@ -1386,6 +1540,8 @@ export const initializeSqliteJournal = Effect.fn("SqliteJournal.initialize")(fun
     getThread,
     getTailDigestAt,
     loadCheckpoint,
+    loadRecoveryCheckpoint,
+    saveRecoveryCheckpoint,
     materialize,
     read,
     saveCheckpoint,

package/dist/migrations-dnTR0RKq.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations-dnTR0RKq.mjs","names":[],"sources":["../src/internal/message-delivery-schema.ts","../src/internal/migrations.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\";\n\n/** Additive storage owned by this adapter; creation participates in its version transaction. */\nexport const createMessageDeliveryTables = Effect.gen(function* () {\n  const sql = yield* SqlClient.SqlClient;\n\n  yield* sql`\n    CREATE TABLE effect_agent_message_deliveries (\n      owner_thread_id TEXT NOT NULL,\n      message_id TEXT NOT NULL,\n      version INTEGER NOT NULL,\n      state TEXT NOT NULL,\n      deadline_at_millis INTEGER,\n      record_json TEXT NOT NULL,\n      PRIMARY KEY (owner_thread_id, message_id)\n    )\n  `.withoutTransform;\n  yield* sql`\n    CREATE INDEX effect_agent_message_deliveries_due\n    ON effect_agent_message_deliveries (deadline_at_millis, owner_thread_id, message_id)\n    WHERE deadline_at_millis IS NOT NULL\n  `.withoutTransform;\n});\n","import { SqliteMigrator } from \"@effect/sql-sqlite-node\";\nimport { Effect } from \"effect\";\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\";\n\nimport { createMessageDeliveryTables } from \"./message-delivery-schema.ts\";\n\nexport const CurrentSqliteStorageVersion = 9;\n\n/** Initialize empty storage with the complete current schema. */\nexport const sqliteMigrations = SqliteMigrator.fromRecord({\n  \"1_current_thread_storage\": Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n\n    yield* sql`\n      CREATE TABLE effect_agent_threads (\n        thread_id TEXT PRIMARY KEY NOT NULL,\n        created_at TEXT NOT NULL,\n        tail_sequence INTEGER NOT NULL,\n        tail_digest TEXT NOT NULL,\n        producer_epoch INTEGER NOT NULL\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_canonical_batches (\n        thread_id TEXT NOT NULL,\n        batch_id TEXT NOT NULL,\n        first_sequence INTEGER NOT NULL,\n        last_sequence INTEGER NOT NULL,\n        batch_digest TEXT NOT NULL,\n        tail_digest TEXT NOT NULL,\n        batch_json TEXT NOT NULL,\n        PRIMARY KEY (thread_id, batch_id),\n        FOREIGN KEY (thread_id)\n          REFERENCES effect_agent_threads(thread_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_canonical_records (\n        thread_id TEXT NOT NULL,\n        sequence INTEGER NOT NULL,\n        record_id TEXT NOT NULL,\n        batch_id TEXT NOT NULL,\n        record_json TEXT NOT NULL,\n        PRIMARY KEY (thread_id, sequence),\n        UNIQUE (thread_id, record_id),\n        FOREIGN KEY (thread_id, batch_id)\n          REFERENCES effect_agent_canonical_batches(thread_id, batch_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE INDEX effect_agent_canonical_records_batch\n        ON effect_agent_canonical_records (thread_id, batch_id, sequence)\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_checkpoints (\n        thread_id TEXT NOT NULL,\n        through_sequence INTEGER NOT NULL,\n        tail_digest TEXT NOT NULL,\n        checkpoint_json TEXT NOT NULL,\n        PRIMARY KEY (thread_id, through_sequence),\n        FOREIGN KEY (thread_id)\n          REFERENCES effect_agent_threads(thread_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    // Admission rows exist before Thread materialization (durability §4), so\n    // thread_id intentionally carries no foreign key into effect_agent_threads.\n    yield* sql`\n      CREATE TABLE effect_agent_submissions (\n        submission_id TEXT PRIMARY KEY NOT NULL,\n        thread_id TEXT NOT NULL,\n        queue_sequence INTEGER NOT NULL,\n        principal TEXT NOT NULL,\n        idempotency_key TEXT NOT NULL,\n        agent_id TEXT NOT NULL,\n        agent_digests_json TEXT NOT NULL,\n        deployment_id TEXT NOT NULL,\n        input_json TEXT NOT NULL,\n        input_digest TEXT NOT NULL,\n        receipt_id TEXT NOT NULL,\n        state TEXT NOT NULL,\n        settled_outcome TEXT,\n        created_at TEXT NOT NULL,\n        ready_at TEXT,\n        input_applied_record_id TEXT,\n        input_applied_sequence INTEGER,\n        joined_host_submission_id TEXT,\n        suspended_reason_json TEXT,\n        suspended_at TEXT,\n        unknown_reason TEXT,\n        unknown_tool_call_ids_json TEXT,\n        parent_submission_id TEXT,\n        parent_tool_call_id TEXT,\n        admission_group TEXT,\n        admission_fence_json TEXT,\n        worker_admission_json TEXT,\n        message_admission_json TEXT,\n        UNIQUE (thread_id, principal, idempotency_key),\n        UNIQUE (thread_id, queue_sequence)\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE INDEX effect_agent_submissions_group\n        ON effect_agent_submissions (thread_id, admission_group, state)\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_submission_ownership (\n        submission_id TEXT PRIMARY KEY NOT NULL,\n        attempt_id TEXT NOT NULL,\n        ownership_token TEXT NOT NULL,\n        producer_epoch INTEGER NOT NULL,\n        owner_producer_id TEXT NOT NULL,\n        lease_expires_at TEXT NOT NULL,\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_attempts (\n        attempt_id TEXT PRIMARY KEY NOT NULL,\n        submission_id TEXT NOT NULL,\n        thread_id TEXT NOT NULL,\n        owner_producer_id TEXT NOT NULL,\n        producer_epoch INTEGER NOT NULL,\n        claimed_at TEXT NOT NULL,\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_settlement_reservations (\n        submission_id TEXT PRIMARY KEY NOT NULL,\n        settlement_id TEXT NOT NULL,\n        outcome TEXT NOT NULL,\n        record_id TEXT NOT NULL,\n        record_json TEXT NOT NULL,\n        record_digest TEXT NOT NULL,\n        reserved_at TEXT NOT NULL,\n        finalized_at TEXT,\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_abort_intents (\n        submission_id TEXT PRIMARY KEY NOT NULL,\n        author TEXT NOT NULL,\n        reason TEXT NOT NULL,\n        requested_at TEXT NOT NULL,\n        canonical_record_id TEXT,\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE INDEX effect_agent_submissions_joined_host\n        ON effect_agent_submissions (joined_host_submission_id)\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_approval_decisions (\n        submission_id TEXT NOT NULL,\n        tool_call_id TEXT NOT NULL,\n        decision TEXT NOT NULL,\n        resolver TEXT NOT NULL,\n        reason TEXT NOT NULL,\n        decided_at TEXT NOT NULL,\n        PRIMARY KEY (submission_id, tool_call_id),\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_unknown_resolutions (\n        submission_id TEXT NOT NULL,\n        tool_call_id TEXT NOT NULL,\n        author TEXT NOT NULL,\n        reason TEXT NOT NULL,\n        resolution_json TEXT NOT NULL,\n        resolved_at TEXT NOT NULL,\n        PRIMARY KEY (submission_id, tool_call_id),\n        FOREIGN KEY (submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    // Durable attached children (spec §12, SUB-004): a child Submission records its immutable\n    // parent linkage at admission; the parent-side index serves the recovery attachment view.\n    yield* sql`\n      CREATE INDEX effect_agent_submissions_parent\n        ON effect_agent_submissions (parent_submission_id)\n    `.withoutTransform;\n\n    // Parent-owned child budget reservations (spec §12 steps 2 and 6, SUB-010): generic\n    // opaque-payload state-machine rows (D8) — allocation and accounting are Schema-encoded\n    // JSON documents the adapter never interprets; status moves\n    // reserved → releasePending → released, applied exactly once.\n    yield* sql`\n      CREATE TABLE effect_agent_child_reservations (\n        reservation_id TEXT PRIMARY KEY NOT NULL,\n        parent_submission_id TEXT NOT NULL,\n        parent_tool_call_id TEXT NOT NULL,\n        child_submission_id TEXT,\n        status TEXT NOT NULL,\n        allocation_json TEXT NOT NULL,\n        allocation_digest TEXT NOT NULL,\n        accounting_json TEXT,\n        reserved_at TEXT NOT NULL,\n        release_began_at TEXT,\n        released_at TEXT,\n        UNIQUE (parent_submission_id, parent_tool_call_id),\n        FOREIGN KEY (parent_submission_id)\n          REFERENCES effect_agent_submissions(submission_id)\n          ON DELETE RESTRICT\n      )\n    `.withoutTransform;\n\n    // record_json is authoritative. The remaining columns support owner keyset paging and\n    // deadline queries without decoding unrelated future schedules.\n    yield* sql`\n      CREATE TABLE effect_agent_schedules (\n        tenant_id TEXT NOT NULL,\n        owner_id TEXT NOT NULL,\n        schedule_id TEXT NOT NULL,\n        deadline_at_millis INTEGER,\n        record_json TEXT NOT NULL,\n        PRIMARY KEY (tenant_id, owner_id, schedule_id)\n      )\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE INDEX effect_agent_schedules_deadline\n        ON effect_agent_schedules (deadline_at_millis, tenant_id, owner_id, schedule_id)\n        WHERE deadline_at_millis IS NOT NULL\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE INDEX effect_agent_schedules_owner_deadline\n        ON effect_agent_schedules (tenant_id, owner_id, deadline_at_millis, schedule_id)\n        WHERE deadline_at_millis IS NOT NULL\n    `.withoutTransform;\n\n    yield* sql`\n      CREATE TABLE effect_agent_subscription_sequences (\n        tenant_id TEXT NOT NULL,\n        source_address TEXT NOT NULL,\n        sequence INTEGER NOT NULL,\n        event_scan_cursor TEXT NOT NULL,\n        delivery_scan_cursor TEXT NOT NULL,\n        recovery_scan_cursor INTEGER NOT NULL,\n        PRIMARY KEY (tenant_id, source_address)\n      )\n    `.withoutTransform;\n    yield* sql`\n      CREATE TABLE effect_agent_subscriptions (\n        tenant_id TEXT NOT NULL,\n        source_address TEXT NOT NULL,\n        owner_id TEXT NOT NULL,\n        subscription_id TEXT NOT NULL,\n        ordinal INTEGER NOT NULL,\n        source_name TEXT NOT NULL,\n        source_version TEXT NOT NULL,\n        matching_key TEXT NOT NULL,\n        state TEXT NOT NULL,\n        expires_at_millis INTEGER,\n        recovery_at_millis INTEGER,\n        recovery_present INTEGER NOT NULL DEFAULT 0,\n        record_json TEXT NOT NULL,\n        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id),\n        UNIQUE (tenant_id, source_address, ordinal)\n      )\n    `.withoutTransform;\n    yield* sql`CREATE INDEX effect_agent_subscriptions_owner ON effect_agent_subscriptions (tenant_id, source_address, owner_id, ordinal)`\n      .withoutTransform;\n    yield* sql`CREATE INDEX effect_agent_subscriptions_candidates ON effect_agent_subscriptions (tenant_id, source_address, source_name, source_version, matching_key, ordinal)`\n      .withoutTransform;\n    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`\n      .withoutTransform;\n    yield* sql`\n      CREATE TABLE effect_agent_subscription_events (\n        tenant_id TEXT NOT NULL,\n        source_address TEXT NOT NULL,\n        event_id TEXT NOT NULL,\n        source_name TEXT NOT NULL,\n        source_version TEXT NOT NULL,\n        matching_key TEXT NOT NULL,\n        payload_digest TEXT NOT NULL,\n        cutoff INTEGER NOT NULL,\n        cursor INTEGER NOT NULL,\n        routing_complete INTEGER NOT NULL,\n        tombstone INTEGER NOT NULL DEFAULT 0,\n        next_attempt_at_millis INTEGER NOT NULL,\n        record_json TEXT NOT NULL,\n        PRIMARY KEY (tenant_id, source_address, event_id)\n      )\n    `.withoutTransform;\n    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)`\n      .withoutTransform;\n    yield* sql`\n      CREATE TABLE effect_agent_subscription_deliveries (\n        tenant_id TEXT NOT NULL,\n        source_address TEXT NOT NULL,\n        owner_id TEXT NOT NULL,\n        subscription_id TEXT NOT NULL,\n        event_id TEXT NOT NULL,\n        delivery_key TEXT NOT NULL,\n        state TEXT NOT NULL,\n        next_attempt_at_millis INTEGER NOT NULL,\n        record_json TEXT NOT NULL,\n        PRIMARY KEY (tenant_id, source_address, owner_id, subscription_id, event_id),\n        UNIQUE (tenant_id, source_address, delivery_key)\n      )\n    `.withoutTransform;\n    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)`\n      .withoutTransform;\n    yield* sql`CREATE INDEX effect_agent_subscription_deliveries_registration ON effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, delivery_key)`\n      .withoutTransform;\n    yield* createMessageDeliveryTables;\n    yield* sql`PRAGMA user_version = 9`.withoutTransform;\n  }),\n});\n"],"mappings":";;;;;AAIA,MAAa,8BAA8B,OAAO,IAAI,aAAa;CACjE,MAAM,MAAM,OAAO,UAAU;CAE7B,OAAO,GAAG;;;;;;;;;;IAUR;CACF,OAAO,GAAG;;;;IAIR;AACJ,CAAC;;;ACjBD,MAAa,8BAA8B;;AAG3C,MAAa,mBAAmB,eAAe,WAAW,EACxD,4BAA4B,OAAO,IAAI,aAAa;CAClD,MAAM,MAAM,OAAO,UAAU;CAE7B,OAAO,GAAG;;;;;;;;MAQR;CAEF,OAAO,GAAG;;;;;;;;;;;;;;MAcR;CAEF,OAAO,GAAG;;;;;;;;;;;;;MAaR;CAEF,OAAO,GAAG;;;MAGR;CAEF,OAAO,GAAG;;;;;;;;;;;MAWR;CAIF,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiCR;CAEF,OAAO,GAAG;;;MAGR;CAEF,OAAO,GAAG;;;;;;;;;;;;MAYR;CAEF,OAAO,GAAG;;;;;;;;;;;;MAYR;CAEF,OAAO,GAAG;;;;;;;;;;;;;;MAcR;CAEF,OAAO,GAAG;;;;;;;;;;;MAWR;CAEF,OAAO,GAAG;;;MAGR;CAEF,OAAO,GAAG;;;;;;;;;;;;;MAaR;CAEF,OAAO,GAAG;;;;;;;;;;;;;MAaR;CAIF,OAAO,GAAG;;;MAGR;CAMF,OAAO,GAAG;;;;;;;;;;;;;;;;;;MAkBR;CAIF,OAAO,GAAG;;;;;;;;;MASR;CAEF,OAAO,GAAG;;;;MAIR;CAEF,OAAO,GAAG;;;;MAIR;CAEF,OAAO,GAAG;;;;;;;;;;MAUR;CACF,OAAO,GAAG;;;;;;;;;;;;;;;;;;MAkBR;CACF,OAAO,GAAG,6HACP;CACH,OAAO,GAAG,mKACP;CACH,OAAO,GAAG,+KACP;CACH,OAAO,GAAG;;;;;;;;;;;;;;;;;MAiBR;CACF,OAAO,GAAG,4KACP;CACH,OAAO,GAAG;;;;;;;;;;;;;;MAcR;CACF,OAAO,GAAG,6KACP;CACH,OAAO,GAAG,8KACP;CACH,OAAO;CACP,OAAO,GAAG,0BAA0B;AACtC,CAAC,EACH,CAAC"}