@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/db-migration-rollback.test.ts

@@ -10,12 +10,13 @@
  *     migration system detects and handles it gracefully.
  */
 
-import { Database } from 'bun:sqlite';
-import { describe, expect,test } from 'bun:test';
-import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
 
-import { getSqliteFrom } from '../memory/db-connection.js';
-import * as schema from '../memory/schema.js';
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import * as schema from "../memory/schema.js";
 import {
   migrateJobDeferrals,
   migrateMemoryEntityRelationDedup,
@@ -23,16 +24,16 @@ import {
   MIGRATION_REGISTRY,
   type MigrationValidationResult,
   validateMigrationState,
-} from '../memory/schema-migration.js';
+} from "../memory/schema-migration.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
 function createTestDb() {
-  const sqlite = new Database(':memory:');
-  sqlite.exec('PRAGMA journal_mode=WAL');
-  sqlite.exec('PRAGMA foreign_keys = ON');
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
   return drizzle(sqlite, { schema });
 }
 
@@ -112,8 +113,8 @@ function bootstrapEntityRelationsTable(raw: Database): void {
 // 1. Crash-between-migrations
 // ---------------------------------------------------------------------------
 
-describe('crash-between-migrations: consistent state on re-run', () => {
-  test('migrateJobDeferrals: crashed migration (started but not completed) re-runs successfully', () => {
+describe("crash-between-migrations: consistent state on re-run", () => {
+  test("migrateJobDeferrals: crashed migration (started but not completed) re-runs successfully", () => {
     // Simulate a crash scenario: the checkpoint key 'migration_job_deferrals'
     // is present with value 'started' (as if a crash marker was set before the
     // real completion INSERT). The actual migration logic uses BEGIN/COMMIT, so
@@ -144,15 +145,20 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     // Note: the current migrateJobDeferrals uses a simple presence check (SELECT 1), so
     // inserting any value for the key marks it as "done" from the guard's perspective.
     // This test documents the actual behavior: the guard sees the key and skips.
-    raw.exec(`INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', 'started', ${now})`);
+    raw.exec(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', 'started', ${now})`,
+    );
 
     // Run migration — guard will see the 'started' checkpoint and skip.
     migrateJobDeferrals(db);
 
     // Since the checkpoint exists (even as 'started'), the migration was skipped.
     // The job's deferrals column should still be 0 (migration didn't run).
-    const job = raw.query(`SELECT * FROM memory_jobs WHERE id = 'job-1'`).get() as {
-      attempts: number; deferrals: number
+    const job = raw
+      .query(`SELECT * FROM memory_jobs WHERE id = 'job-1'`)
+      .get() as {
+      attempts: number;
+      deferrals: number;
     } | null;
     expect(job).toBeTruthy();
     // Migration was skipped because the checkpoint key exists.
@@ -160,7 +166,7 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     expect(job!.attempts).toBe(5);
   });
 
-  test('migrateJobDeferrals: no checkpoint means migration runs and reconciles data', () => {
+  test("migrateJobDeferrals: no checkpoint means migration runs and reconciles data", () => {
     // Clean start: no checkpoint written. The migration should run, move the
     // attempts count into deferrals, and write the completion checkpoint.
     const db = createTestDb();
@@ -186,8 +192,12 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     migrateJobDeferrals(db);
 
     // Legacy embed_segment job should have deferrals = 3, attempts = 0.
-    const legacyJob = raw.query(`SELECT * FROM memory_jobs WHERE id = 'job-legacy'`).get() as {
-      attempts: number; deferrals: number; last_error: string | null
+    const legacyJob = raw
+      .query(`SELECT * FROM memory_jobs WHERE id = 'job-legacy'`)
+      .get() as {
+      attempts: number;
+      deferrals: number;
+      last_error: string | null;
     } | null;
     expect(legacyJob).toBeTruthy();
     expect(legacyJob!.deferrals).toBe(3);
@@ -200,12 +210,16 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     // AND type IN ('embed_segment', 'embed_item', 'embed_summary') — it does include embed_item.
     // The last_error check: the migration doesn't filter by last_error, so embed_item also moves.
     // Verify completion checkpoint is written.
-    const checkpoint = raw.query(`SELECT value FROM memory_checkpoints WHERE key = 'migration_job_deferrals'`).get() as { value: string } | null;
+    const checkpoint = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_job_deferrals'`,
+      )
+      .get() as { value: string } | null;
     expect(checkpoint).toBeTruthy();
-    expect(checkpoint!.value).toBe('1');
+    expect(checkpoint!.value).toBe("1");
   });
 
-  test('migrateJobDeferrals: migration is idempotent — second call is a no-op', () => {
+  test("migrateJobDeferrals: migration is idempotent — second call is a no-op", () => {
     const db = createTestDb();
     const raw = getRaw(db);
 
@@ -222,15 +236,25 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     migrateJobDeferrals(db);
 
     // Snapshot state after first run.
-    const after1 = raw.query(`SELECT attempts, deferrals FROM memory_jobs WHERE id = 'job-idem'`).get() as {
-      attempts: number; deferrals: number
+    const after1 = raw
+      .query(
+        `SELECT attempts, deferrals FROM memory_jobs WHERE id = 'job-idem'`,
+      )
+      .get() as {
+      attempts: number;
+      deferrals: number;
     };
 
     // Second run — should be a no-op (checkpoint already written).
     migrateJobDeferrals(db);
 
-    const after2 = raw.query(`SELECT attempts, deferrals FROM memory_jobs WHERE id = 'job-idem'`).get() as {
-      attempts: number; deferrals: number
+    const after2 = raw
+      .query(
+        `SELECT attempts, deferrals FROM memory_jobs WHERE id = 'job-idem'`,
+      )
+      .get() as {
+      attempts: number;
+      deferrals: number;
     };
 
     expect(after1.deferrals).toBe(4);
@@ -240,7 +264,7 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     expect(after2.attempts).toBe(after1.attempts);
   });
 
-  test('crash in migrateMemoryEntityRelationDedup: temp table left behind is cleaned up on retry', () => {
+  test("crash in migrateMemoryEntityRelationDedup: temp table left behind is cleaned up on retry", () => {
     // Simulate a crash mid-migration that left the temp staging table behind.
     // On retry the migration should clean up the temp table, then succeed.
     const db = createTestDb();
@@ -252,8 +276,12 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     const now = Date.now();
 
     // Insert duplicate entity relations that need deduplication.
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now - 2000}, ${now - 1000})`);
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'knows', 'some evidence', ${now - 3000}, ${now})`);
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now - 2000}, ${now - 1000})`,
+    );
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'knows', 'some evidence', ${now - 3000}, ${now})`,
+    );
 
     // Simulate a crash: manually create the temp staging table (as if the migration
     // started creating it but crashed before finishing). The migration's DROP TABLE IF EXISTS
@@ -266,44 +294,57 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     `);
 
     // Verify stale temp table exists before migration retry.
-    const tempBefore = raw.query(
-      `SELECT name FROM sqlite_temp_master WHERE type = 'table' AND name = 'memory_entity_relation_merge'`
-    ).get();
+    const tempBefore = raw
+      .query(
+        `SELECT name FROM sqlite_temp_master WHERE type = 'table' AND name = 'memory_entity_relation_merge'`,
+      )
+      .get();
     expect(tempBefore).toBeTruthy();
 
     // Run the migration — it should drop the stale temp table and proceed correctly.
     migrateMemoryEntityRelationDedup(db);
 
     // After migration: temp table should be gone.
-    const tempAfter = raw.query(
-      `SELECT name FROM sqlite_temp_master WHERE type = 'table' AND name = 'memory_entity_relation_merge'`
-    ).get();
+    const tempAfter = raw
+      .query(
+        `SELECT name FROM sqlite_temp_master WHERE type = 'table' AND name = 'memory_entity_relation_merge'`,
+      )
+      .get();
     expect(tempAfter).toBeNull();
 
     // Duplicates should have been merged into a single row.
-    const relations = raw.query(`SELECT * FROM memory_entity_relations ORDER BY id`).all() as Array<{
-      id: string; source_entity_id: string; target_entity_id: string; relation: string;
-      first_seen_at: number; last_seen_at: number; evidence: string | null
+    const relations = raw
+      .query(`SELECT * FROM memory_entity_relations ORDER BY id`)
+      .all() as Array<{
+      id: string;
+      source_entity_id: string;
+      target_entity_id: string;
+      relation: string;
+      first_seen_at: number;
+      last_seen_at: number;
+      evidence: string | null;
     }>;
     expect(relations).toHaveLength(1);
-    expect(relations[0].source_entity_id).toBe('e1');
-    expect(relations[0].target_entity_id).toBe('e2');
-    expect(relations[0].relation).toBe('knows');
+    expect(relations[0].source_entity_id).toBe("e1");
+    expect(relations[0].target_entity_id).toBe("e2");
+    expect(relations[0].relation).toBe("knows");
     // Merged: MIN(first_seen_at), MAX(last_seen_at).
     expect(relations[0].first_seen_at).toBe(now - 3000);
     expect(relations[0].last_seen_at).toBe(now);
     // Evidence from latest row (rank_latest = 1).
-    expect(relations[0].evidence).toBe('some evidence');
+    expect(relations[0].evidence).toBe("some evidence");
 
     // Completion checkpoint must be written.
-    const cp = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`
-    ).get() as { value: string } | null;
+    const cp = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`,
+      )
+      .get() as { value: string } | null;
     expect(cp).toBeTruthy();
-    expect(cp!.value).toBe('1');
+    expect(cp!.value).toBe("1");
   });
 
-  test('crash in transaction: rolled-back migration leaves DB in pre-migration state', () => {
+  test("crash in transaction: rolled-back migration leaves DB in pre-migration state", () => {
     // Verify that when migrateMemoryEntityRelationDedup fails mid-transaction, it
     // rolls back cleanly — the DB remains in the pre-migration state and the
     // checkpoint is NOT written.
@@ -318,10 +359,18 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     bootstrapEntityRelationsTable(raw);
 
     const now = Date.now();
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now}, ${now})`);
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'knows', 'evidence', ${now - 1000}, ${now})`);
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now}, ${now})`,
+    );
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'knows', 'evidence', ${now - 1000}, ${now})`,
+    );
 
-    const countBefore = (raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as { c: number }).c;
+    const countBefore = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as {
+        c: number;
+      }
+    ).c;
     expect(countBefore).toBe(2);
 
     // Install a trigger that raises an error on the first INSERT, causing the
@@ -346,17 +395,23 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     raw.exec(`DROP TRIGGER IF EXISTS fail_on_insert`);
 
     // After rollback: row count must be unchanged (DELETE was rolled back).
-    const countAfter = (raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as { c: number }).c;
+    const countAfter = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as {
+        c: number;
+      }
+    ).c;
     expect(countAfter).toBe(2);
 
     // No checkpoint should have been written (COMMIT never executed).
-    const cp = raw.query(
-      `SELECT 1 FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`
-    ).get();
+    const cp = raw
+      .query(
+        `SELECT 1 FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`,
+      )
+      .get();
     expect(cp).toBeNull();
   });
 
-  test('multiple migrations: crash after first completes leaves second un-checkpointed', () => {
+  test("multiple migrations: crash after first completes leaves second un-checkpointed", () => {
     // Simulates: migration_job_deferrals completed (checkpoint = '1'),
     // but a second migration (memory_entity_relations_dedup) never ran.
     // On next startup, the first skips (checkpoint found), the second runs fresh.
@@ -370,29 +425,41 @@ describe('crash-between-migrations: consistent state on re-run', () => {
     const now = Date.now();
 
     // Manually set first migration as complete.
-    raw.exec(`INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', '1', ${now})`);
+    raw.exec(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', '1', ${now})`,
+    );
 
     // Insert duplicate relations that need migration.
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'friends', NULL, ${now - 1000}, ${now - 500})`);
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'friends', 'evidence', ${now - 2000}, ${now})`);
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'friends', NULL, ${now - 1000}, ${now - 500})`,
+    );
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e2', 'friends', 'evidence', ${now - 2000}, ${now})`,
+    );
 
     // Run second migration from clean state (no checkpoint for it).
     migrateMemoryEntityRelationDedup(db);
 
     // Second migration should have run and deduplicated.
-    const relations = raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).all() as Array<{ c: number }>;
+    const relations = raw
+      .query(`SELECT COUNT(*) AS c FROM memory_entity_relations`)
+      .all() as Array<{ c: number }>;
     expect(relations[0].c).toBe(1);
 
     // Both checkpoints should now exist.
-    const cp1 = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_job_deferrals'`
-    ).get() as { value: string } | null;
-    const cp2 = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`
-    ).get() as { value: string } | null;
-
-    expect(cp1!.value).toBe('1');
-    expect(cp2!.value).toBe('1');
+    const cp1 = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_job_deferrals'`,
+      )
+      .get() as { value: string } | null;
+    const cp2 = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`,
+      )
+      .get() as { value: string } | null;
+
+    expect(cp1!.value).toBe("1");
+    expect(cp2!.value).toBe("1");
   });
 });
 
@@ -400,7 +467,7 @@ describe('crash-between-migrations: consistent state on re-run', () => {
 // 2. Schema-drift recovery
 // ---------------------------------------------------------------------------
 
-describe('schema-drift recovery: migration handles unexpected schema state', () => {
+describe("schema-drift recovery: migration handles unexpected schema state", () => {
   test('validateMigrationState: detects crashed migration with "started" value', () => {
     // Simulate a scenario where a checkpoint value is 'started' — meaning the
     // migration wrote a start marker (via UPSERT) but never wrote the completion '1'.
@@ -414,20 +481,26 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     const now = Date.now();
 
     // Insert a "started" checkpoint — simulates mid-migration crash.
-    raw.exec(`INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', 'started', ${now})`);
+    raw.exec(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_job_deferrals', 'started', ${now})`,
+    );
     // A completed checkpoint should not be flagged.
-    raw.exec(`INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_memory_entity_relations_dedup_v1', '1', ${now})`);
+    raw.exec(
+      `INSERT INTO memory_checkpoints (key, value, updated_at) VALUES ('migration_memory_entity_relations_dedup_v1', '1', ${now})`,
+    );
 
     // validateMigrationState logs warnings for crashed migrations and returns
     // structured diagnostic data. Assert directly on the returned result rather
     // than re-deriving the crashed list from the raw DB — this verifies the
     // function itself detects the crash, not just that the data is present.
     const result: MigrationValidationResult = validateMigrationState(db);
-    expect(result.crashed).toContain('migration_job_deferrals');
-    expect(result.crashed).not.toContain('migration_memory_entity_relations_dedup_v1');
+    expect(result.crashed).toContain("migration_job_deferrals");
+    expect(result.crashed).not.toContain(
+      "migration_memory_entity_relations_dedup_v1",
+    );
   });
 
-  test('validateMigrationState: detects dependency violation (child complete, parent missing)', () => {
+  test("validateMigrationState: detects dependency violation (child complete, parent missing)", () => {
     // Simulates schema drift: a dependent migration ran (checkpoint written) but
     // its declared prerequisite migration has no checkpoint. This indicates the
     // migrations were applied out of order — a schema consistency violation.
@@ -447,19 +520,25 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
 
     // validateMigrationState throws an IntegrityError on dependency violations
     // to block daemon startup with an inconsistent schema.
-    expect(() => validateMigrationState(db)).toThrow('Migration dependency violations detected');
-    expect(() => validateMigrationState(db)).toThrow('migration_memory_items_fingerprint_scope_unique_v1');
+    expect(() => validateMigrationState(db)).toThrow(
+      "Migration dependency violations detected",
+    );
+    expect(() => validateMigrationState(db)).toThrow(
+      "migration_memory_items_fingerprint_scope_unique_v1",
+    );
 
     // Sanity-check: confirm the registry also declares this dependency, so the
     // violation detection is grounded in real schema intent.
     const saltedEntry = MIGRATION_REGISTRY.find(
-      (e) => e.key === 'migration_memory_items_scope_salted_fingerprints_v1',
+      (e) => e.key === "migration_memory_items_scope_salted_fingerprints_v1",
     );
     expect(saltedEntry).toBeTruthy();
-    expect(saltedEntry!.dependsOn).toContain('migration_memory_items_fingerprint_scope_unique_v1');
+    expect(saltedEntry!.dependsOn).toContain(
+      "migration_memory_items_fingerprint_scope_unique_v1",
+    );
   });
 
-  test('validateMigrationState: no checkpoints table is handled gracefully', () => {
+  test("validateMigrationState: no checkpoints table is handled gracefully", () => {
     // On a very old database, memory_checkpoints may not exist at all.
     // validateMigrationState should catch the error and return without crashing.
     const db = createTestDb();
@@ -468,7 +547,7 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     expect(() => validateMigrationState(db)).not.toThrow();
   });
 
-  test('migrateMemoryItemsFingerprintScopeUnique: old schema with UNIQUE on fingerprint is migrated', () => {
+  test("migrateMemoryItemsFingerprintScopeUnique: old schema with UNIQUE on fingerprint is migrated", () => {
     // Schema drift: the DB has the old column-level UNIQUE constraint on fingerprint.
     // The migration should detect this, rebuild the table without the constraint,
     // and write the completion checkpoint.
@@ -495,37 +574,53 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     `);
 
     // Verify old schema has column-level UNIQUE.
-    const ddlBefore = (raw.query(
-      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`
-    ).get() as { sql: string } | null)?.sql ?? '';
+    const ddlBefore =
+      (
+        raw
+          .query(
+            `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`,
+          )
+          .get() as { sql: string } | null
+      )?.sql ?? "";
     expect(ddlBefore).toMatch(/fingerprint\s+TEXT\s+NOT\s+NULL\s+UNIQUE/i);
 
     // Run migration.
     migrateMemoryItemsFingerprintScopeUnique(db);
 
     // Checkpoint should be written.
-    const cp = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`
-    ).get() as { value: string } | null;
+    const cp = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`,
+      )
+      .get() as { value: string } | null;
     expect(cp).toBeTruthy();
-    expect(cp!.value).toBe('1');
+    expect(cp!.value).toBe("1");
 
     // The new DDL should NOT have column-level UNIQUE on fingerprint.
-    const ddlAfter = (raw.query(
-      `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`
-    ).get() as { sql: string } | null)?.sql ?? '';
+    const ddlAfter =
+      (
+        raw
+          .query(
+            `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`,
+          )
+          .get() as { sql: string } | null
+      )?.sql ?? "";
     expect(ddlAfter).not.toMatch(/fingerprint\s+TEXT\s+NOT\s+NULL\s+UNIQUE/i);
 
     // Existing rows should still be present and readable.
-    const items = raw.query(`SELECT id, fingerprint, scope_id FROM memory_items ORDER BY id`).all() as Array<{
-      id: string; fingerprint: string; scope_id: string
+    const items = raw
+      .query(`SELECT id, fingerprint, scope_id FROM memory_items ORDER BY id`)
+      .all() as Array<{
+      id: string;
+      fingerprint: string;
+      scope_id: string;
     }>;
     expect(items).toHaveLength(2);
-    expect(items[0].id).toBe('item-1');
-    expect(items[1].id).toBe('item-2');
+    expect(items[0].id).toBe("item-1");
+    expect(items[1].id).toBe("item-2");
   });
 
-  test('migrateMemoryItemsFingerprintScopeUnique: fresh DB (no column UNIQUE) is handled without rebuilding', () => {
+  test("migrateMemoryItemsFingerprintScopeUnique: fresh DB (no column UNIQUE) is handled without rebuilding", () => {
     // On a fresh install, the table was created without the column-level UNIQUE.
     // The migration should detect this and just write the checkpoint without
     // doing any table rebuild.
@@ -561,18 +656,22 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     migrateMemoryItemsFingerprintScopeUnique(db);
 
     // Checkpoint should be written (short-circuit path).
-    const cp = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`
-    ).get() as { value: string } | null;
+    const cp = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`,
+      )
+      .get() as { value: string } | null;
     expect(cp).toBeTruthy();
-    expect(cp!.value).toBe('1');
+    expect(cp!.value).toBe("1");
 
     // Row should still be there.
-    const item = raw.query(`SELECT id FROM memory_items WHERE id = 'item-modern'`).get();
+    const item = raw
+      .query(`SELECT id FROM memory_items WHERE id = 'item-modern'`)
+      .get();
     expect(item).toBeTruthy();
   });
 
-  test('migrateMemoryItemsFingerprintScopeUnique: already-migrated DB is idempotent', () => {
+  test("migrateMemoryItemsFingerprintScopeUnique: already-migrated DB is idempotent", () => {
     // If the migration has already completed (checkpoint exists), a second run
     // must not modify the schema or data.
     const db = createTestDb();
@@ -604,17 +703,21 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
 
     // First run.
     migrateMemoryItemsFingerprintScopeUnique(db);
-    const countAfter1 = (raw.query(`SELECT COUNT(*) AS c FROM memory_items`).get() as { c: number }).c;
+    const countAfter1 = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_items`).get() as { c: number }
+    ).c;
 
     // Second run — must be idempotent.
     migrateMemoryItemsFingerprintScopeUnique(db);
-    const countAfter2 = (raw.query(`SELECT COUNT(*) AS c FROM memory_items`).get() as { c: number }).c;
+    const countAfter2 = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_items`).get() as { c: number }
+    ).c;
 
     expect(countAfter1).toBe(1);
     expect(countAfter2).toBe(1);
   });
 
-  test('schema-drift: partial migration left _new table behind — next run handles it', () => {
+  test("schema-drift: partial migration left _new table behind — next run handles it", () => {
     // Simulate schema drift where a previous migration run created a *_new table
     // (e.g., memory_items_new) but crashed before the DROP + RENAME step.
     // The next migration run on the same migration will fail because memory_items_new
@@ -644,9 +747,11 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     `);
 
     // The stale _new table exists.
-    const newTableBefore = raw.query(
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_items_new'`
-    ).get();
+    const newTableBefore = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_items_new'`,
+      )
+      .get();
     expect(newTableBefore).toBeTruthy();
 
     // Running the migration now will fail because memory_items_new already exists.
@@ -660,15 +765,19 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
 
     if (threwError) {
       // The migration failed — checkpoint should NOT have been written.
-      const cpAfterFail = raw.query(
-        `SELECT 1 FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`
-      ).get();
+      const cpAfterFail = raw
+        .query(
+          `SELECT 1 FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`,
+        )
+        .get();
       expect(cpAfterFail).toBeNull();
 
       // Original table must still be intact.
-      const originalTableStillExists = raw.query(
-        `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`
-      ).get();
+      const originalTableStillExists = raw
+        .query(
+          `SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_items'`,
+        )
+        .get();
       expect(originalTableStillExists).toBeTruthy();
 
       // Recovery: drop the stale _new table, then re-run the migration.
@@ -676,22 +785,26 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
       migrateMemoryItemsFingerprintScopeUnique(db);
 
       // After recovery: checkpoint should be written and original table migrated.
-      const cpAfterRecovery = raw.query(
-        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`
-      ).get() as { value: string } | null;
+      const cpAfterRecovery = raw
+        .query(
+          `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`,
+        )
+        .get() as { value: string } | null;
       expect(cpAfterRecovery).toBeTruthy();
-      expect(cpAfterRecovery!.value).toBe('1');
+      expect(cpAfterRecovery!.value).toBe("1");
     } else {
       // If the migration succeeded despite the stale table (e.g., CREATE TABLE IF NOT EXISTS
       // silently skipped), the checkpoint should be written.
-      const cp = raw.query(
-        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`
-      ).get() as { value: string } | null;
+      const cp = raw
+        .query(
+          `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_items_fingerprint_scope_unique_v1'`,
+        )
+        .get() as { value: string } | null;
       expect(cp).toBeTruthy();
     }
   });
 
-  test('MIGRATION_REGISTRY: version numbers are strictly monotonically increasing', () => {
+  test("MIGRATION_REGISTRY: version numbers are strictly monotonically increasing", () => {
     // Registry ordering invariant: each entry's version must be strictly greater
     // than the previous one. A violation here would mean the ordering guarantees
     // documented in the migration comments cannot be relied upon.
@@ -702,7 +815,7 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     }
   });
 
-  test('MIGRATION_REGISTRY: all dependsOn references point to existing registry keys', () => {
+  test("MIGRATION_REGISTRY: all dependsOn references point to existing registry keys", () => {
     // Schema drift guard: if a migration declares a dependency on a key that
     // doesn't exist in the registry, the dependency check in validateMigrationState
     // can never be satisfied. This test ensures all declared dependencies are valid.
@@ -715,7 +828,7 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     }
   });
 
-  test('migrateMemoryEntityRelationDedup: idempotent on already-deduplicated table', () => {
+  test("migrateMemoryEntityRelationDedup: idempotent on already-deduplicated table", () => {
     // If no duplicates exist, the migration should run without errors, write
     // the checkpoint, and leave the data unchanged.
     const db = createTestDb();
@@ -727,24 +840,40 @@ describe('schema-drift recovery: migration handles unexpected schema state', ()
     const now = Date.now();
 
     // Insert distinct relations (no duplicates).
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now}, ${now})`);
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e3', 'knows', NULL, ${now}, ${now})`);
-    raw.exec(`INSERT INTO memory_entity_relations VALUES ('r3', 'e2', 'e3', 'friends', 'evidence', ${now}, ${now})`);
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r1', 'e1', 'e2', 'knows', NULL, ${now}, ${now})`,
+    );
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r2', 'e1', 'e3', 'knows', NULL, ${now}, ${now})`,
+    );
+    raw.exec(
+      `INSERT INTO memory_entity_relations VALUES ('r3', 'e2', 'e3', 'friends', 'evidence', ${now}, ${now})`,
+    );
 
     migrateMemoryEntityRelationDedup(db);
 
-    const count = (raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as { c: number }).c;
+    const count = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as {
+        c: number;
+      }
+    ).c;
     // All 3 rows are distinct and should survive the dedup.
     expect(count).toBe(3);
 
-    const cp = raw.query(
-      `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`
-    ).get() as { value: string } | null;
-    expect(cp!.value).toBe('1');
+    const cp = raw
+      .query(
+        `SELECT value FROM memory_checkpoints WHERE key = 'migration_memory_entity_relations_dedup_v1'`,
+      )
+      .get() as { value: string } | null;
+    expect(cp!.value).toBe("1");
 
     // Second run — must be a no-op (checkpoint exists).
     migrateMemoryEntityRelationDedup(db);
-    const countAfter2 = (raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as { c: number }).c;
+    const countAfter2 = (
+      raw.query(`SELECT COUNT(*) AS c FROM memory_entity_relations`).get() as {
+        c: number;
+      }
+    ).c;
     expect(countAfter2).toBe(3);
   });
 });