@codexa/cli 9.0.30 → 9.0.32

package/db/schema.test.ts

@@ -1,32 +1,21 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { mkdirSync, rmSync, existsSync } from "fs";
-import { join } from "path";
-
-// Setup: use a temporary directory for test databases
-const TEST_DIR = join(import.meta.dir, "..", ".test-db");
-const TEST_DB_PATH = join(TEST_DIR, "test.db");
-
-// We need to override the DB path before importing schema functions.
-// The connection module uses process.cwd() so we mock via direct DB manipulation.
+import { createClient, type Client } from "@libsql/client";
+import { setClient, resetClient, dbGet, dbAll, dbRun, dbExec } from "./connection";
 
 describe("Migration System", () => {
-  let db: Database;
+  let client: Client;
 
   beforeEach(() => {
-    // Create in-memory database with same schema setup
-    db = new Database(":memory:");
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
+    client = createClient({ url: ":memory:" });
+    setClient(client);
   });
 
   afterEach(() => {
-    db.close();
+    resetClient();
   });
 
-  function createBaseTables(db: Database) {
-    // Minimal table creation to test migrations against
-    db.exec(`
+  async function createBaseTables() {
+    await dbExec(`
       CREATE TABLE IF NOT EXISTS specs (
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
@@ -34,16 +23,18 @@ describe("Migration System", () => {
         approved_at TEXT,
         created_at TEXT DEFAULT CURRENT_TIMESTAMP,
         updated_at TEXT
-      );
-
+      )
+    `);
+    await dbExec(`
       CREATE TABLE IF NOT EXISTS project (
         id TEXT PRIMARY KEY DEFAULT 'default',
         name TEXT,
         stack TEXT NOT NULL,
         discovered_at TEXT,
         updated_at TEXT
-      );
-
+      )
+    `);
+    await dbExec(`
       CREATE TABLE IF NOT EXISTS tasks (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -57,8 +48,9 @@ describe("Migration System", () => {
         checkpoint TEXT,
         completed_at TEXT,
         UNIQUE(spec_id, number)
-      );
-
+      )
+    `);
+    await dbExec(`
       CREATE TABLE IF NOT EXISTS decisions (
         id TEXT PRIMARY KEY,
         spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -68,103 +60,101 @@ describe("Migration System", () => {
         rationale TEXT,
         status TEXT DEFAULT 'active',
         created_at TEXT DEFAULT CURRENT_TIMESTAMP
-      );
-
+      )
+    `);
+    await dbExec(`
       CREATE TABLE IF NOT EXISTS schema_migrations (
         version TEXT PRIMARY KEY,
         description TEXT NOT NULL,
         applied_at TEXT DEFAULT CURRENT_TIMESTAMP
-      );
+      )
     `);
   }
 
-  // ═══════════════════════════════════════════════════════════════
-  // runMigrations() tests
-  // ═══════════════════════════════════════════════════════════════
-
   describe("runMigrations()", () => {
-    it("should apply all migrations on a fresh database", () => {
-      createBaseTables(db);
+    it("should apply all migrations on a fresh database", async () => {
+      await createBaseTables();
 
-      // Define test migrations
       const migrations = [
         {
           version: "8.4.0",
           description: "Add analysis_id to specs",
-          up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+          up: async () => await dbExec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
         },
         {
           version: "8.7.0",
           description: "Add cli_version to project",
-          up: (d: Database) => d.exec("ALTER TABLE project ADD COLUMN cli_version TEXT"),
+          up: async () => await dbExec("ALTER TABLE project ADD COLUMN cli_version TEXT"),
         },
       ];
 
-      // Run migrations manually (simulating runMigrations logic)
       for (const migration of migrations) {
-        const existing = db.query("SELECT version FROM schema_migrations WHERE version = ?").get(migration.version);
+        const existing = await dbGet<{ version: string }>(
+          "SELECT version FROM schema_migrations WHERE version = ?",
+          [migration.version]
+        );
         if (existing) continue;
 
-        migration.up(db);
-        db.run(
+        await migration.up();
+        await dbRun(
           "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
           [migration.version, migration.description]
         );
       }
 
-      // Verify all migrations were recorded
-      const applied = db.query("SELECT * FROM schema_migrations ORDER BY version").all() as any[];
+      const applied = await dbAll<{ version: string }>(
+        "SELECT * FROM schema_migrations ORDER BY version"
+      );
       expect(applied.length).toBe(2);
       expect(applied[0].version).toBe("8.4.0");
       expect(applied[1].version).toBe("8.7.0");
 
-      // Verify columns were added
-      const columns = db.query("PRAGMA table_info(specs)").all() as any[];
-      const colNames = columns.map((c: any) => c.name);
+      const columns = await dbAll<{ name: string }>("PRAGMA table_info(specs)");
+      const colNames = columns.map((c) => c.name);
       expect(colNames).toContain("analysis_id");
     });
 
-    it("should be idempotent — calling twice applies each migration only once", () => {
-      createBaseTables(db);
+    it("should be idempotent — calling twice applies each migration only once", async () => {
+      await createBaseTables();
 
       const migration = {
         version: "8.4.0",
         description: "Add analysis_id to specs",
-        up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+        up: async () => await dbExec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
       };
 
-      // First run
-      migration.up(db);
-      db.run(
+      await migration.up();
+      await dbRun(
         "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
         [migration.version, migration.description]
       );
 
-      // Second run — should skip because already applied
-      const existing = db.query("SELECT version FROM schema_migrations WHERE version = ?").get(migration.version);
+      const existing = await dbGet<{ version: string }>(
+        "SELECT version FROM schema_migrations WHERE version = ?",
+        [migration.version]
+      );
       expect(existing).not.toBeNull();
 
-      // Verify only 1 record
-      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
-      expect(applied.c).toBe(1);
+      const applied = await dbGet<{ c: number }>(
+        "SELECT COUNT(*) as c FROM schema_migrations"
+      );
+      expect(applied!.c).toBe(1);
     });
 
-    it("should absorb 'duplicate column name' errors from pre-migration databases", () => {
-      createBaseTables(db);
+    it("should absorb 'duplicate column name' errors from pre-migration databases", async () => {
+      await createBaseTables();
 
-      // Manually add the column first (simulating pre-migration DB)
-      db.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT");
+      await dbExec("ALTER TABLE specs ADD COLUMN analysis_id TEXT");
 
-      // Now try to run the migration — should NOT throw
       const migration = {
         version: "8.4.0",
         description: "Add analysis_id to specs",
-        up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+        up: async () => await dbExec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
       };
 
       let absorbed = false;
       try {
-        migration.up(db);
+        await migration.up();
       } catch (e: any) {
         if (e.message.includes("duplicate column name")) {
           absorbed = true;
@@ -175,41 +165,36 @@ describe("Migration System", () => {
 
       expect(absorbed).toBe(true);
 
-      // Record it anyway
-      db.run(
+      await dbRun(
         "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
         [migration.version, migration.description]
       );
 
-      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
-      expect(applied.c).toBe(1);
+      const applied = await dbGet<{ c: number }>(
+        "SELECT COUNT(*) as c FROM schema_migrations"
+      );
+      expect(applied!.c).toBe(1);
     });
 
-    it("should propagate real errors (not duplicate column)", () => {
-      createBaseTables(db);
+    it("should propagate real errors (not duplicate column)", async () => {
+      await createBaseTables();
 
       const badMigration = {
         version: "99.0.0",
         description: "Bad migration",
-        up: (d: Database) => d.exec("ALTER TABLE nonexistent_table ADD COLUMN foo TEXT"),
+        up: async () => await dbExec("ALTER TABLE nonexistent_table ADD COLUMN foo TEXT"),
       };
 
-      expect(() => {
-        badMigration.up(db);
-      }).toThrow();
+      expect(badMigration.up()).rejects.toThrow();
 
-      // Migration should NOT be recorded
-      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
-      expect(applied.c).toBe(0);
+      const applied = await dbGet<{ c: number }>(
+        "SELECT COUNT(*) as c FROM schema_migrations"
+      );
+      expect(applied!.c).toBe(0);
     });
   });
 
-  // ═══════════════════════════════════════════════════════════════
-  // getNextDecisionId() tests
-  // ═══════════════════════════════════════════════════════════════
-
   describe("getNextDecisionId()", () => {
-    // Reimplemented: uses timestamp+random instead of sequential count
     function getNextDecisionId(specId: string): string {
       const slug = specId.split("-").slice(1, 3).join("-");
       const ts = Date.now().toString(36);
@@ -234,7 +219,6 @@ describe("Migration System", () => {
     });
 
     it("should not require DB access (no race condition)", () => {
-      // Generate 100 IDs rapidly — all should be unique
       const ids = new Set<string>();
       for (let i = 0; i < 100; i++) {
         ids.add(getNextDecisionId("SPEC-001"));
@@ -243,76 +227,69 @@ describe("Migration System", () => {
     });
   });
 
-  // ═══════════════════════════════════════════════════════════════
-  // claimTask() tests
-  // ═══════════════════════════════════════════════════════════════
-
   describe("claimTask()", () => {
-    function claimTask(taskId: number): boolean {
-      const result = db.run(
+    async function claimTask(taskId: number): Promise<boolean> {
+      const result = await dbRun(
         "UPDATE tasks SET status = 'running' WHERE id = ? AND status = 'pending'",
         [taskId]
       );
       return result.changes > 0;
     }
 
-    beforeEach(() => {
-      createBaseTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
-      db.run(
+    beforeEach(async () => {
+      await createBaseTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      await dbRun(
         "INSERT INTO tasks (spec_id, number, name, status) VALUES (?, ?, ?, ?)",
         ["SPEC-001", 1, "Test task", "pending"]
       );
     });
 
-    it("should return true and set status to running for a pending task", () => {
-      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
-      expect(claimTask(taskId)).toBe(true);
+    it("should return true and set status to running for a pending task", async () => {
+      const row = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 1");
+      const taskId = row!.id;
+      expect(await claimTask(taskId)).toBe(true);
 
-      const task = db.query("SELECT status FROM tasks WHERE id = ?").get(taskId) as any;
-      expect(task.status).toBe("running");
+      const task = await dbGet<{ status: string }>("SELECT status FROM tasks WHERE id = ?", [taskId]);
+      expect(task!.status).toBe("running");
     });
 
-    it("should return false for a task already in running status", () => {
-      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+    it("should return false for a task already in running status", async () => {
+      const row = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 1");
+      const taskId = row!.id;
 
-      // First claim succeeds
-      expect(claimTask(taskId)).toBe(true);
-      // Second claim fails
-      expect(claimTask(taskId)).toBe(false);
+      expect(await claimTask(taskId)).toBe(true);
+      expect(await claimTask(taskId)).toBe(false);
     });
 
-    it("should return false for a task in done status", () => {
-      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
-      db.run("UPDATE tasks SET status = 'done' WHERE id = ?", [taskId]);
+    it("should return false for a task in done status", async () => {
+      const row = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 1");
+      const taskId = row!.id;
+      await dbRun("UPDATE tasks SET status = 'done' WHERE id = ?", [taskId]);
 
-      expect(claimTask(taskId)).toBe(false);
+      expect(await claimTask(taskId)).toBe(false);
     });
 
-    it("should return false for a non-existent task ID", () => {
-      expect(claimTask(99999)).toBe(false);
+    it("should return false for a non-existent task ID", async () => {
+      expect(await claimTask(99999)).toBe(false);
     });
 
-    it("should prevent double-claim (only first caller wins)", () => {
-      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+    it("should prevent double-claim (only first caller wins)", async () => {
+      const row = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 1");
+      const taskId = row!.id;
 
-      // Simulate two concurrent claims
-      const claim1 = claimTask(taskId);
-      const claim2 = claimTask(taskId);
+      const claim1 = await claimTask(taskId);
+      const claim2 = await claimTask(taskId);
 
       expect(claim1).toBe(true);
       expect(claim2).toBe(false);
     });
   });
 
-  // ═══════════════════════════════════════════════════════════════
-  // v9.3: Agent Performance (P3.2)
-  // ═══════════════════════════════════════════════════════════════
-
   describe("agent_performance", () => {
-    function createPerformanceTables(db: Database) {
-      createBaseTables(db);
-      db.exec(`
+    async function createPerformanceTables() {
+      await createBaseTables();
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS agent_performance (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           agent_type TEXT NOT NULL,
@@ -328,9 +305,8 @@ describe("Migration System", () => {
           created_at TEXT DEFAULT CURRENT_TIMESTAMP
         )
       `);
-      db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_perf_type ON agent_performance(agent_type)`);
-
-      db.exec(`
+      await dbExec("CREATE INDEX IF NOT EXISTS idx_agent_perf_type ON agent_performance(agent_type)");
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS gate_bypasses (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           spec_id TEXT,
@@ -342,11 +318,11 @@ describe("Migration System", () => {
       `);
     }
 
-    it("migration 9.3.0 should create agent_performance table", () => {
-      createPerformanceTables(db);
+    it("migration 9.3.0 should create agent_performance table", async () => {
+      await createPerformanceTables();
 
-      const columns = db.query("PRAGMA table_info(agent_performance)").all() as any[];
-      const colNames = columns.map((c: any) => c.name);
+      const columns = await dbAll<{ name: string }>("PRAGMA table_info(agent_performance)");
+      const colNames = columns.map((c) => c.name);
       expect(colNames).toContain("agent_type");
       expect(colNames).toContain("spec_id");
       expect(colNames).toContain("task_id");
@@ -356,46 +332,49 @@ describe("Migration System", () => {
       expect(colNames).toContain("execution_duration_ms");
     });
 
-    it("should insert and retrieve performance data", () => {
-      createPerformanceTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
-      db.run(
+    it("should insert and retrieve performance data", async () => {
+      await createPerformanceTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      await dbRun(
         "INSERT INTO tasks (spec_id, number, name, agent, status) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "Test task", "frontend-next", "done"]
       );
 
       const now = new Date().toISOString();
-      db.run(
+      await dbRun(
         `INSERT INTO agent_performance
          (agent_type, spec_id, task_id, gates_passed_first_try, gates_total, bypasses_used, files_created, files_modified, context_size_bytes, execution_duration_ms, created_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         ["frontend-next", "SPEC-001", 1, 7, 7, 0, 3, 1, 4096, 15000, now]
       );
 
-      const rows = db.query("SELECT * FROM agent_performance WHERE agent_type = ?").all("frontend-next") as any[];
+      const rows = await dbAll<any>(
+        "SELECT * FROM agent_performance WHERE agent_type = ?",
+        ["frontend-next"]
+      );
       expect(rows).toHaveLength(1);
       expect(rows[0].gates_passed_first_try).toBe(7);
       expect(rows[0].bypasses_used).toBe(0);
       expect(rows[0].execution_duration_ms).toBe(15000);
     });
 
-    it("should compute hints: no data returns empty", () => {
-      createPerformanceTables(db);
+    it("should compute hints: no data returns empty", async () => {
+      await createPerformanceTables();
 
-      const recent = db.query(
-        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
-      ).all("nonexistent") as any[];
+      const recent = await dbAll<any>(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5",
+        ["nonexistent"]
+      );
       expect(recent).toHaveLength(0);
     });
 
-    it("should detect high bypass rate from performance data", () => {
-      createPerformanceTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+    it("should detect high bypass rate from performance data", async () => {
+      await createPerformanceTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
 
       const now = new Date().toISOString();
-      // Insert 3 records with bypasses
       for (let i = 1; i <= 3; i++) {
-        db.run(
+        await dbRun(
           `INSERT INTO agent_performance
            (agent_type, spec_id, task_id, gates_passed_first_try, gates_total, bypasses_used, created_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)`,
@@ -403,9 +382,10 @@ describe("Migration System", () => {
         );
       }
 
-      const recent = db.query(
-        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
-      ).all("backend-go") as any[];
+      const recent = await dbAll<any>(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5",
+        ["backend-go"]
+      );
 
       const avgBypass = recent.reduce((sum: number, r: any) => sum + r.bypasses_used, 0) / recent.length;
       expect(avgBypass).toBe(2);
@@ -415,16 +395,16 @@ describe("Migration System", () => {
         return sum + (r.gates_total > 0 ? r.gates_passed_first_try / r.gates_total : 1);
       }, 0) / recent.length;
       expect(avgGateRate).toBeCloseTo(5 / 7, 2);
-      expect(avgGateRate < 0.7).toBe(false); // 5/7 ≈ 0.71, just above threshold
+      expect(avgGateRate < 0.7).toBe(false);
     });
 
-    it("should detect low gate pass rate", () => {
-      createPerformanceTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+    it("should detect low gate pass rate", async () => {
+      await createPerformanceTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
 
       const now = new Date().toISOString();
       for (let i = 1; i <= 3; i++) {
-        db.run(
+        await dbRun(
           `INSERT INTO agent_performance
            (agent_type, spec_id, task_id, gates_passed_first_try, gates_total, bypasses_used, created_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)`,
@@ -432,45 +412,52 @@ describe("Migration System", () => {
         );
       }
 
-      const recent = db.query(
-        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
-      ).all("backend-csharp") as any[];
+      const recent = await dbAll<any>(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5",
+        ["backend-csharp"]
+      );
 
       const avgGateRate = recent.reduce((sum: number, r: any) => {
         return sum + (r.gates_total > 0 ? r.gates_passed_first_try / r.gates_total : 1);
       }, 0) / recent.length;
       expect(avgGateRate).toBeCloseTo(3 / 7, 2);
-      expect(avgGateRate < 0.7).toBe(true); // 3/7 ≈ 0.43 — should trigger hint
+      expect(avgGateRate < 0.7).toBe(true);
     });
 
-    it("should track frequent gate bypass types", () => {
-      createPerformanceTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
-      db.run(
+    it("should track frequent gate bypass types", async () => {
+      await createPerformanceTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      await dbRun(
         "INSERT INTO tasks (spec_id, number, name, agent, status) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "Task 1", "frontend-next", "done"]
       );
-      db.run(
+      await dbRun(
         "INSERT INTO tasks (spec_id, number, name, agent, status) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 2, "Task 2", "frontend-next", "done"]
       );
 
-      const taskId1 = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
-      const taskId2 = (db.query("SELECT id FROM tasks WHERE number = 2").get() as any).id;
+      const row1 = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 1");
+      const row2 = await dbGet<{ id: number }>("SELECT id FROM tasks WHERE number = 2");
+      const taskId1 = row1!.id;
+      const taskId2 = row2!.id;
 
-      // Add bypasses for same gate
-      db.run("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, ?, ?)",
-        ["SPEC-001", taskId1, "standards-follow", "test"]);
-      db.run("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, ?, ?)",
-        ["SPEC-001", taskId2, "standards-follow", "test"]);
+      await dbRun(
+        "INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, ?, ?)",
+        ["SPEC-001", taskId1, "standards-follow", "test"]
+      );
+      await dbRun(
+        "INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, ?, ?)",
+        ["SPEC-001", taskId2, "standards-follow", "test"]
+      );
 
-      const bypassTypes = db.query(
+      const bypassTypes = await dbAll<any>(
         `SELECT gb.gate_name, COUNT(*) as cnt FROM gate_bypasses gb
          JOIN tasks t ON gb.task_id = t.id
          WHERE t.agent = ?
          GROUP BY gb.gate_name
-         ORDER BY cnt DESC LIMIT 3`
-      ).all("frontend-next") as any[];
+         ORDER BY cnt DESC LIMIT 3`,
+        ["frontend-next"]
+      );
 
       expect(bypassTypes).toHaveLength(1);
       expect(bypassTypes[0].gate_name).toBe("standards-follow");
@@ -478,14 +465,10 @@ describe("Migration System", () => {
     });
   });
 
-  // ═══════════════════════════════════════════════════════════════
-  // v9.4: Knowledge Acknowledgments (P1-5)
-  // ═══════════════════════════════════════════════════════════════
-
   describe("knowledge_acknowledgments", () => {
-    function createKnowledgeTables(db: Database) {
-      createBaseTables(db);
-      db.exec(`
+    async function createKnowledgeTables() {
+      await createBaseTables();
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS knowledge (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           spec_id TEXT NOT NULL,
@@ -494,11 +477,10 @@ describe("Migration System", () => {
           content TEXT NOT NULL,
           severity TEXT DEFAULT 'info',
           broadcast_to TEXT DEFAULT 'all',
-          acknowledged_by TEXT,
           created_at TEXT DEFAULT CURRENT_TIMESTAMP
         )
       `);
-      db.exec(`
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS knowledge_acknowledgments (
           knowledge_id INTEGER NOT NULL REFERENCES knowledge(id) ON DELETE CASCADE,
           task_id INTEGER NOT NULL,
@@ -506,118 +488,141 @@ describe("Migration System", () => {
           PRIMARY KEY (knowledge_id, task_id)
         )
       `);
-      db.exec(`CREATE INDEX IF NOT EXISTS idx_ka_task ON knowledge_acknowledgments(task_id)`);
+      await dbExec("CREATE INDEX IF NOT EXISTS idx_ka_task ON knowledge_acknowledgments(task_id)");
     }
 
-    it("migration 9.4.0 should create knowledge_acknowledgments table", () => {
-      createKnowledgeTables(db);
+    it("migration 9.4.0 should create knowledge_acknowledgments table", async () => {
+      await createKnowledgeTables();
 
-      const columns = db.query("PRAGMA table_info(knowledge_acknowledgments)").all() as any[];
-      const colNames = columns.map((c: any) => c.name);
+      const columns = await dbAll<{ name: string }>("PRAGMA table_info(knowledge_acknowledgments)");
+      const colNames = columns.map((c) => c.name);
       expect(colNames).toContain("knowledge_id");
       expect(colNames).toContain("task_id");
       expect(colNames).toContain("acknowledged_at");
     });
 
-    it("should insert and query acknowledgment", () => {
-      createKnowledgeTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
-      db.run(
+    it("should insert and query acknowledgment", async () => {
+      await createKnowledgeTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      await dbRun(
         "INSERT INTO knowledge (spec_id, task_origin, category, content, severity) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "discovery", "Test knowledge", "critical"]
       );
 
-      const kid = (db.query("SELECT id FROM knowledge LIMIT 1").get() as any).id;
+      const kRow = await dbGet<{ id: number }>("SELECT id FROM knowledge LIMIT 1");
+      const kid = kRow!.id;
 
-      // Not acknowledged yet
-      const before = db.query(
-        "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
-      ).get(kid, 2);
+      const before = await dbGet(
+        "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?",
+        [kid, 2]
+      );
       expect(before).toBeNull();
 
-      // Acknowledge
-      db.run(
+      await dbRun(
         "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
         [kid, 2]
       );
 
-      // Now acknowledged
-      const after = db.query(
-        "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
-      ).get(kid, 2);
+      const after = await dbGet(
+        "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?",
+        [kid, 2]
+      );
       expect(after).not.toBeNull();
     });
 
-    it("should be idempotent (INSERT OR IGNORE)", () => {
-      createKnowledgeTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
-      db.run(
+    it("should be idempotent (INSERT OR IGNORE)", async () => {
+      await createKnowledgeTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      await dbRun(
         "INSERT INTO knowledge (spec_id, task_origin, category, content) VALUES (?, ?, ?, ?)",
         ["SPEC-001", 1, "discovery", "Test"]
       );
 
-      const kid = (db.query("SELECT id FROM knowledge LIMIT 1").get() as any).id;
+      const kRow = await dbGet<{ id: number }>("SELECT id FROM knowledge LIMIT 1");
+      const kid = kRow!.id;
 
-      // Insert twice — no error
-      db.run("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kid, 2]);
-      db.run("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kid, 2]);
+      await dbRun("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kid, 2]);
+      await dbRun("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kid, 2]);
 
-      const count = (db.query(
-        "SELECT COUNT(*) as c FROM knowledge_acknowledgments WHERE knowledge_id = ?"
-      ).get(kid) as any).c;
-      expect(count).toBe(1);
+      const count = await dbGet<{ c: number }>(
+        "SELECT COUNT(*) as c FROM knowledge_acknowledgments WHERE knowledge_id = ?",
+        [kid]
+      );
+      expect(count!.c).toBe(1);
     });
 
-    it("should migrate data from JSON acknowledged_by", () => {
-      createKnowledgeTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+    it("should migrate data from JSON acknowledged_by", async () => {
+      await createBaseTables();
+      await dbExec(`
+        CREATE TABLE IF NOT EXISTS knowledge (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          spec_id TEXT NOT NULL,
+          task_origin INTEGER NOT NULL,
+          category TEXT NOT NULL,
+          content TEXT NOT NULL,
+          severity TEXT DEFAULT 'info',
+          broadcast_to TEXT DEFAULT 'all',
+          acknowledged_by TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      await dbExec(`
+        CREATE TABLE IF NOT EXISTS knowledge_acknowledgments (
+          knowledge_id INTEGER NOT NULL REFERENCES knowledge(id) ON DELETE CASCADE,
+          task_id INTEGER NOT NULL,
+          acknowledged_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          PRIMARY KEY (knowledge_id, task_id)
+        )
+      `);
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
 
-      // Insert with old JSON format
-      db.run(
+      await dbRun(
         "INSERT INTO knowledge (spec_id, task_origin, category, content, acknowledged_by) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "discovery", "Test", JSON.stringify([2, 3, 5])]
       );
 
-      const kid = (db.query("SELECT id FROM knowledge LIMIT 1").get() as any).id;
+      const kRow = await dbGet<{ id: number }>("SELECT id FROM knowledge LIMIT 1");
+      const kid = kRow!.id;
 
-      // Simulate migration
-      const rows = db.query("SELECT id, acknowledged_by FROM knowledge WHERE acknowledged_by IS NOT NULL").all() as any[];
-      const insert = db.prepare("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)");
+      const rows = await dbAll<{ id: number; acknowledged_by: string }>(
+        "SELECT id, acknowledged_by FROM knowledge WHERE acknowledged_by IS NOT NULL"
+      );
       for (const row of rows) {
         const taskIds = JSON.parse(row.acknowledged_by) as number[];
         for (const taskId of taskIds) {
-          insert.run(row.id, taskId);
+          await dbRun(
+            "INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)",
+            [row.id, taskId]
+          );
         }
       }
 
-      // Verify migrated data
-      const acks = db.query(
-        "SELECT task_id FROM knowledge_acknowledgments WHERE knowledge_id = ? ORDER BY task_id"
-      ).all(kid) as any[];
-      expect(acks.map((a: any) => a.task_id)).toEqual([2, 3, 5]);
+      const acks = await dbAll<{ task_id: number }>(
+        "SELECT task_id FROM knowledge_acknowledgments WHERE knowledge_id = ? ORDER BY task_id",
+        [kid]
+      );
+      expect(acks.map((a) => a.task_id)).toEqual([2, 3, 5]);
     });
 
-    it("should find unacknowledged critical knowledge via NOT EXISTS", () => {
-      createKnowledgeTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+    it("should find unacknowledged critical knowledge via NOT EXISTS", async () => {
+      await createKnowledgeTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
 
-      // Insert critical knowledge from task 1
-      db.run(
+      await dbRun(
         "INSERT INTO knowledge (spec_id, task_origin, category, content, severity) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "discovery", "Critical A", "critical"]
       );
-      db.run(
+      await dbRun(
         "INSERT INTO knowledge (spec_id, task_origin, category, content, severity) VALUES (?, ?, ?, ?, ?)",
         ["SPEC-001", 1, "discovery", "Critical B", "critical"]
       );
 
-      const kids = (db.query("SELECT id FROM knowledge ORDER BY id").all() as any[]).map((r: any) => r.id);
+      const allK = await dbAll<{ id: number }>("SELECT id FROM knowledge ORDER BY id");
+      const kids = allK.map((r) => r.id);
 
-      // Acknowledge only the first one by task 2
-      db.run("INSERT INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kids[0], 2]);
+      await dbRun("INSERT INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kids[0], 2]);
 
-      // Query unacknowledged for task 2
-      const unacked = db.query(`
+      const unacked = await dbAll<any>(`
         SELECT k.* FROM knowledge k
         WHERE k.spec_id = ?
           AND k.severity = 'critical'
@@ -626,21 +631,17 @@ describe("Migration System", () => {
             SELECT 1 FROM knowledge_acknowledgments ka
             WHERE ka.knowledge_id = k.id AND ka.task_id = ?
           )
-      `).all("SPEC-001", 2, 2) as any[];
+      `, ["SPEC-001", 2, 2]);
 
       expect(unacked).toHaveLength(1);
       expect(unacked[0].content).toBe("Critical B");
     });
   });
 
-  // ═══════════════════════════════════════════════════════════════
-  // P1-2: Review Score
-  // ═══════════════════════════════════════════════════════════════
-
   describe("calculateReviewScore()", () => {
-    function createReviewTables(db: Database) {
-      createBaseTables(db);
-      db.exec(`
+    async function createReviewTables() {
+      await createBaseTables();
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS artifacts (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           spec_id TEXT NOT NULL,
@@ -649,7 +650,9 @@ describe("Migration System", () => {
           action TEXT NOT NULL,
           created_at TEXT DEFAULT CURRENT_TIMESTAMP,
           UNIQUE(spec_id, path)
-        );
+        )
+      `);
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS gate_bypasses (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           spec_id TEXT NOT NULL,
@@ -657,55 +660,60 @@ describe("Migration System", () => {
           gate_name TEXT NOT NULL,
           reason TEXT,
           created_at TEXT DEFAULT CURRENT_TIMESTAMP
-        );
+        )
+      `);
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS review (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           spec_id TEXT NOT NULL,
           planned_vs_done TEXT,
           deviations TEXT,
-          pattern_violations TEXT,
           status TEXT DEFAULT 'pending',
-          resolution TEXT,
           created_at TEXT DEFAULT CURRENT_TIMESTAMP
-        );
+        )
       `);
     }
 
-    function calcScore(db: Database, specId: string) {
-      const totalTasks = (db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?").get(specId) as any).c;
-      const completedTasks = (db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'").get(specId) as any).c;
+    async function calcScore(specId: string) {
+      const totalRow = await dbGet<{ c: number }>("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?", [specId]);
+      const totalTasks = totalRow!.c;
+      const completedRow = await dbGet<{ c: number }>("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'", [specId]);
+      const completedTasks = completedRow!.c;
       const tasksCompleted = totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 25) : 25;
 
       const totalGateEvents = totalTasks * 7;
-      const bypassCount = (db.query("SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ?").get(specId) as any).c;
+      const bypassRow = await dbGet<{ c: number }>("SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ?", [specId]);
+      const bypassCount = bypassRow!.c;
       const cleanGateEvents = Math.max(0, totalGateEvents - bypassCount);
       const gatesPassedClean = totalGateEvents > 0 ? Math.round((cleanGateEvents / totalGateEvents) * 25) : 25;
 
-      const plannedFiles = db.query("SELECT files FROM tasks WHERE spec_id = ? AND files IS NOT NULL").all(specId) as any[];
+      const plannedFiles = await dbAll<{ files: string }>("SELECT files FROM tasks WHERE spec_id = ? AND files IS NOT NULL", [specId]);
       const allPlannedFiles = new Set<string>();
       for (const t of plannedFiles) {
         try { for (const f of JSON.parse(t.files) as string[]) allPlannedFiles.add(f); } catch {}
       }
-      const deliveredFiles = new Set((db.query("SELECT DISTINCT path FROM artifacts WHERE spec_id = ?").all(specId) as any[]).map(a => a.path));
+      const deliveredRows = await dbAll<{ path: string }>("SELECT DISTINCT path FROM artifacts WHERE spec_id = ?", [specId]);
+      const deliveredFiles = new Set(deliveredRows.map(a => a.path));
       let filesDelivered: number;
       if (allPlannedFiles.size === 0) { filesDelivered = deliveredFiles.size > 0 ? 25 : 0; }
       else { let m = 0; for (const f of allPlannedFiles) { if (deliveredFiles.has(f)) m++; } filesDelivered = Math.round((m / allPlannedFiles.size) * 25); }
 
-      const standardsBypasses = (db.query("SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ? AND gate_name = 'standards-follow'").get(specId) as any).c;
+      const standardsRow = await dbGet<{ c: number }>("SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ? AND gate_name = 'standards-follow'", [specId]);
+      const standardsBypasses = standardsRow!.c;
       const standardsFollowed = totalTasks > 0 ? Math.round(((totalTasks - standardsBypasses) / totalTasks) * 25) : 25;
 
       return { total: tasksCompleted + gatesPassedClean + filesDelivered + standardsFollowed, breakdown: { tasksCompleted, gatesPassedClean, filesDelivered, standardsFollowed } };
     }
 
-    it("should return perfect score for clean implementation", () => {
-      createReviewTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
-      db.run("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 1, 'Task 1', 'done', ?)", ["SPEC-001", '["src/a.ts"]']);
-      db.run("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 2, 'Task 2', 'done', ?)", ["SPEC-001", '["src/b.ts"]']);
-      db.run("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')", ["SPEC-001"]);
-      db.run("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 2, 'src/b.ts', 'created')", ["SPEC-001"]);
+    it("should return perfect score for clean implementation", async () => {
+      await createReviewTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 1, 'Task 1', 'done', ?)", ["SPEC-001", '["src/a.ts"]']);
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 2, 'Task 2', 'done', ?)", ["SPEC-001", '["src/b.ts"]']);
+      await dbRun("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')", ["SPEC-001"]);
+      await dbRun("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 2, 'src/b.ts', 'created')", ["SPEC-001"]);
 
-      const score = calcScore(db, "SPEC-001");
+      const score = await calcScore("SPEC-001");
       expect(score.total).toBe(100);
       expect(score.breakdown.tasksCompleted).toBe(25);
       expect(score.breakdown.gatesPassedClean).toBe(25);
@@ -713,48 +721,46 @@ describe("Migration System", () => {
       expect(score.breakdown.standardsFollowed).toBe(25);
     });
 
-    it("should penalize incomplete tasks", () => {
-      createReviewTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
-      db.run("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
-      db.run("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 2, 'Task 2', 'pending')", ["SPEC-001"]);
+    it("should penalize incomplete tasks", async () => {
+      await createReviewTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 2, 'Task 2', 'pending')", ["SPEC-001"]);
 
-      const score = calcScore(db, "SPEC-001");
-      expect(score.breakdown.tasksCompleted).toBe(13); // round(1/2 * 25) = 13
+      const score = await calcScore("SPEC-001");
+      expect(score.breakdown.tasksCompleted).toBe(13);
     });
 
-    it("should penalize gate bypasses", () => {
-      createReviewTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
-      db.run("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
-      db.run("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'standards-follow', 'test')", ["SPEC-001"]);
-      db.run("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'dry-check', 'test')", ["SPEC-001"]);
+    it("should penalize gate bypasses", async () => {
+      await createReviewTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
+      await dbRun("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'standards-follow', 'test')", ["SPEC-001"]);
+      await dbRun("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'dry-check', 'test')", ["SPEC-001"]);
 
-      const score = calcScore(db, "SPEC-001");
-      // 1 task * 7 gates = 7 events, 2 bypasses = 5/7 clean
+      const score = await calcScore("SPEC-001");
       expect(score.breakdown.gatesPassedClean).toBe(Math.round(5 / 7 * 25));
     });
 
-    it("should penalize missing files", () => {
-      createReviewTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
-      db.run("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 1, 'Task 1', 'done', ?)", ["SPEC-001", '["src/a.ts","src/b.ts"]']);
-      db.run("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')", ["SPEC-001"]);
-      // src/b.ts missing
+    it("should penalize missing files", async () => {
+      await createReviewTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status, files) VALUES (?, 1, 'Task 1', 'done', ?)", ["SPEC-001", '["src/a.ts","src/b.ts"]']);
+      await dbRun("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')", ["SPEC-001"]);
 
-      const score = calcScore(db, "SPEC-001");
-      expect(score.breakdown.filesDelivered).toBe(13); // round(1/2 * 25) = 13
+      const score = await calcScore("SPEC-001");
+      expect(score.breakdown.filesDelivered).toBe(13);
     });
 
-    it("should penalize standards bypasses specifically", () => {
-      createReviewTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
-      db.run("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
-      db.run("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 2, 'Task 2', 'done')", ["SPEC-001"]);
-      db.run("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'standards-follow', 'test')", ["SPEC-001"]);
+    it("should penalize standards bypasses specifically", async () => {
+      await createReviewTables();
+      await dbRun("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'reviewing')");
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 1, 'Task 1', 'done')", ["SPEC-001"]);
+      await dbRun("INSERT INTO tasks (spec_id, number, name, status) VALUES (?, 2, 'Task 2', 'done')", ["SPEC-001"]);
+      await dbRun("INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, 1, 'standards-follow', 'test')", ["SPEC-001"]);
 
-      const score = calcScore(db, "SPEC-001");
-      expect(score.breakdown.standardsFollowed).toBe(13); // round(1/2 * 25) = 13
+      const score = await calcScore("SPEC-001");
+      expect(score.breakdown.standardsFollowed).toBe(13);
     });
   });
 });