@codexa/cli 9.0.2 → 9.0.4

package/db/schema.test.ts

@@ -0,0 +1,760 @@
+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.
+
+describe("Migration System", () => {
+  let db: Database;
+
+  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");
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  function createBaseTables(db: Database) {
+    // Minimal table creation to test migrations against
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS specs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        phase TEXT NOT NULL DEFAULT 'planning',
+        approved_at TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS project (
+        id TEXT PRIMARY KEY DEFAULT 'default',
+        name TEXT,
+        stack TEXT NOT NULL,
+        discovered_at TEXT,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        spec_id TEXT NOT NULL REFERENCES specs(id),
+        number INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        depends_on TEXT,
+        can_parallel INTEGER DEFAULT 1,
+        agent TEXT,
+        files TEXT,
+        status TEXT DEFAULT 'pending',
+        checkpoint TEXT,
+        completed_at TEXT,
+        UNIQUE(spec_id, number)
+      );
+
+      CREATE TABLE IF NOT EXISTS decisions (
+        id TEXT PRIMARY KEY,
+        spec_id TEXT NOT NULL REFERENCES specs(id),
+        task_ref INTEGER,
+        title TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        rationale TEXT,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      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);
+
+      // 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"),
+        },
+        {
+          version: "8.7.0",
+          description: "Add cli_version to project",
+          up: (d: Database) => d.exec("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);
+        if (existing) continue;
+
+        migration.up(db);
+        db.run(
+          "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[];
+      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);
+      expect(colNames).toContain("analysis_id");
+    });
+
+    it("should be idempotent — calling twice applies each migration only once", () => {
+      createBaseTables(db);
+
+      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"),
+      };
+
+      // First run
+      migration.up(db);
+      db.run(
+        "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);
+      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);
+    });
+
+    it("should absorb 'duplicate column name' errors from pre-migration databases", () => {
+      createBaseTables(db);
+
+      // Manually add the column first (simulating pre-migration DB)
+      db.exec("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"),
+      };
+
+      let absorbed = false;
+      try {
+        migration.up(db);
+      } catch (e: any) {
+        if (e.message.includes("duplicate column name")) {
+          absorbed = true;
+        } else {
+          throw e;
+        }
+      }
+
+      expect(absorbed).toBe(true);
+
+      // Record it anyway
+      db.run(
+        "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);
+    });
+
+    it("should propagate real errors (not duplicate column)", () => {
+      createBaseTables(db);
+
+      const badMigration = {
+        version: "99.0.0",
+        description: "Bad migration",
+        up: (d: Database) => d.exec("ALTER TABLE nonexistent_table ADD COLUMN foo TEXT"),
+      };
+
+      expect(() => {
+        badMigration.up(db);
+      }).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);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // 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);
+      const rand = Math.random().toString(36).substring(2, 6);
+      return `DEC-${slug}-${ts}-${rand}`;
+    }
+
+    it("should start with DEC- prefix and contain spec slug", () => {
+      const id = getNextDecisionId("SPEC-001");
+      expect(id.startsWith("DEC-001-")).toBe(true);
+    });
+
+    it("should generate unique IDs on consecutive calls", () => {
+      const id1 = getNextDecisionId("SPEC-001");
+      const id2 = getNextDecisionId("SPEC-001");
+      expect(id1).not.toBe(id2);
+    });
+
+    it("should include slug from multi-part spec IDs", () => {
+      const id = getNextDecisionId("2026-02-11-feature-name");
+      expect(id.startsWith("DEC-02-11-")).toBe(true);
+    });
+
+    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"));
+      }
+      expect(ids.size).toBe(100);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // claimTask() tests
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("claimTask()", () => {
+    function claimTask(taskId: number): boolean {
+      const result = db.run(
+        "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(
+        "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);
+
+      const task = db.query("SELECT status FROM tasks WHERE id = ?").get(taskId) as any;
+      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;
+
+      // First claim succeeds
+      expect(claimTask(taskId)).toBe(true);
+      // Second claim fails
+      expect(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]);
+
+      expect(claimTask(taskId)).toBe(false);
+    });
+
+    it("should return false for a non-existent task ID", () => {
+      expect(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;
+
+      // Simulate two concurrent claims
+      const claim1 = claimTask(taskId);
+      const claim2 = 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(`
+        CREATE TABLE IF NOT EXISTS agent_performance (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          agent_type TEXT NOT NULL,
+          spec_id TEXT NOT NULL,
+          task_id INTEGER NOT NULL,
+          gates_passed_first_try INTEGER DEFAULT 0,
+          gates_total INTEGER DEFAULT 0,
+          bypasses_used INTEGER DEFAULT 0,
+          files_created INTEGER DEFAULT 0,
+          files_modified INTEGER DEFAULT 0,
+          context_size_bytes INTEGER DEFAULT 0,
+          execution_duration_ms INTEGER DEFAULT 0,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+      db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_perf_type ON agent_performance(agent_type)`);
+
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS gate_bypasses (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          spec_id TEXT,
+          task_id INTEGER,
+          gate_name TEXT NOT NULL,
+          reason TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+    }
+
+    it("migration 9.3.0 should create agent_performance table", () => {
+      createPerformanceTables(db);
+
+      const columns = db.query("PRAGMA table_info(agent_performance)").all() as any[];
+      const colNames = columns.map((c: any) => c.name);
+      expect(colNames).toContain("agent_type");
+      expect(colNames).toContain("spec_id");
+      expect(colNames).toContain("task_id");
+      expect(colNames).toContain("gates_passed_first_try");
+      expect(colNames).toContain("gates_total");
+      expect(colNames).toContain("bypasses_used");
+      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(
+        "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(
+        `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[];
+      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);
+
+      const recent = db.query(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
+      ).all("nonexistent") as any[];
+      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')");
+
+      const now = new Date().toISOString();
+      // Insert 3 records with bypasses
+      for (let i = 1; i <= 3; i++) {
+        db.run(
+          `INSERT INTO agent_performance
+           (agent_type, spec_id, task_id, gates_passed_first_try, gates_total, bypasses_used, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`,
+          ["backend-go", "SPEC-001", i, 5, 7, 2, now]
+        );
+      }
+
+      const recent = db.query(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
+      ).all("backend-go") as any[];
+
+      const avgBypass = recent.reduce((sum: number, r: any) => sum + r.bypasses_used, 0) / recent.length;
+      expect(avgBypass).toBe(2);
+      expect(avgBypass > 0.5).toBe(true);
+
+      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(5 / 7, 2);
+      expect(avgGateRate < 0.7).toBe(false); // 5/7 ≈ 0.71, just above threshold
+    });
+
+    it("should detect low gate pass rate", () => {
+      createPerformanceTables(db);
+      db.run("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(
+          `INSERT INTO agent_performance
+           (agent_type, spec_id, task_id, gates_passed_first_try, gates_total, bypasses_used, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`,
+          ["backend-csharp", "SPEC-001", i, 3, 7, 4, now]
+        );
+      }
+
+      const recent = db.query(
+        "SELECT * FROM agent_performance WHERE agent_type = ? ORDER BY created_at DESC LIMIT 5"
+      ).all("backend-csharp") as any[];
+
+      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
+    });
+
+    it("should track frequent gate bypass types", () => {
+      createPerformanceTables(db);
+      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      db.run(
+        "INSERT INTO tasks (spec_id, number, name, agent, status) VALUES (?, ?, ?, ?, ?)",
+        ["SPEC-001", 1, "Task 1", "frontend-next", "done"]
+      );
+      db.run(
+        "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;
+
+      // 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"]);
+
+      const bypassTypes = db.query(
+        `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[];
+
+      expect(bypassTypes).toHaveLength(1);
+      expect(bypassTypes[0].gate_name).toBe("standards-follow");
+      expect(bypassTypes[0].cnt).toBe(2);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // v9.4: Knowledge Acknowledgments (P1-5)
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("knowledge_acknowledgments", () => {
+    function createKnowledgeTables(db: Database) {
+      createBaseTables(db);
+      db.exec(`
+        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
+        )
+      `);
+      db.exec(`
+        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)
+        )
+      `);
+      db.exec(`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);
+
+      const columns = db.query("PRAGMA table_info(knowledge_acknowledgments)").all() as any[];
+      const colNames = columns.map((c: any) => 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(
+        "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;
+
+      // Not acknowledged yet
+      const before = db.query(
+        "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ? AND task_id = ?"
+      ).get(kid, 2);
+      expect(before).toBeNull();
+
+      // Acknowledge
+      db.run(
+        "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);
+      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(
+        "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;
+
+      // 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]);
+
+      const count = (db.query(
+        "SELECT COUNT(*) as c FROM knowledge_acknowledgments WHERE knowledge_id = ?"
+      ).get(kid) as any).c;
+      expect(count).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')");
+
+      // Insert with old JSON format
+      db.run(
+        "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;
+
+      // 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 (?, ?)");
+      for (const row of rows) {
+        const taskIds = JSON.parse(row.acknowledged_by) as number[];
+        for (const taskId of taskIds) {
+          insert.run(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]);
+    });
+
+    it("should find unacknowledged critical knowledge via NOT EXISTS", () => {
+      createKnowledgeTables(db);
+      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+
+      // Insert critical knowledge from task 1
+      db.run(
+        "INSERT INTO knowledge (spec_id, task_origin, category, content, severity) VALUES (?, ?, ?, ?, ?)",
+        ["SPEC-001", 1, "discovery", "Critical A", "critical"]
+      );
+      db.run(
+        "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);
+
+      // Acknowledge only the first one by task 2
+      db.run("INSERT INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [kids[0], 2]);
+
+      // Query unacknowledged for task 2
+      const unacked = db.query(`
+        SELECT k.* FROM knowledge k
+        WHERE k.spec_id = ?
+          AND k.severity = 'critical'
+          AND k.task_origin != ?
+          AND NOT EXISTS (
+            SELECT 1 FROM knowledge_acknowledgments ka
+            WHERE ka.knowledge_id = k.id AND ka.task_id = ?
+          )
+      `).all("SPEC-001", 2, 2) as any[];
+
+      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(`
+        CREATE TABLE IF NOT EXISTS artifacts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          spec_id TEXT NOT NULL,
+          task_ref INTEGER NOT NULL,
+          path TEXT NOT NULL,
+          action TEXT NOT NULL,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          UNIQUE(spec_id, path)
+        );
+        CREATE TABLE IF NOT EXISTS gate_bypasses (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          spec_id TEXT NOT NULL,
+          task_id INTEGER NOT NULL,
+          gate_name TEXT NOT NULL,
+          reason TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+        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;
+      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 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 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));
+      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 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"]);
+
+      const score = calcScore(db, "SPEC-001");
+      expect(score.total).toBe(100);
+      expect(score.breakdown.tasksCompleted).toBe(25);
+      expect(score.breakdown.gatesPassedClean).toBe(25);
+      expect(score.breakdown.filesDelivered).toBe(25);
+      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"]);
+
+      const score = calcScore(db, "SPEC-001");
+      expect(score.breakdown.tasksCompleted).toBe(13); // round(1/2 * 25) = 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"]);
+
+      const score = calcScore(db, "SPEC-001");
+      // 1 task * 7 gates = 7 events, 2 bypasses = 5/7 clean
+      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
+
+      const score = calcScore(db, "SPEC-001");
+      expect(score.breakdown.filesDelivered).toBe(13); // round(1/2 * 25) = 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"]);
+
+      const score = calcScore(db, "SPEC-001");
+      expect(score.breakdown.standardsFollowed).toBe(13); // round(1/2 * 25) = 13
+    });
+  });
+});