@codexa/cli 9.0.3 → 9.0.4

package/db/schema.test.ts

@@ -209,63 +209,37 @@ describe("Migration System", () => {
   // ═══════════════════════════════════════════════════════════════
 
   describe("getNextDecisionId()", () => {
+    // Reimplemented: uses timestamp+random instead of sequential count
     function getNextDecisionId(specId: string): string {
-      const result = db.query(
-        `SELECT MAX(CAST(REPLACE(id, 'DEC-', '') AS INTEGER)) as max_num
-         FROM decisions WHERE spec_id = ?`
-      ).get(specId) as any;
-
-      const nextNum = (result?.max_num || 0) + 1;
-      return `DEC-${nextNum.toString().padStart(3, "0")}`;
+      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}`;
     }
 
-    beforeEach(() => {
-      createBaseTables(db);
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'planning')");
-    });
-
-    it("should return DEC-001 for empty decisions", () => {
-      expect(getNextDecisionId("SPEC-001")).toBe("DEC-001");
+    it("should start with DEC- prefix and contain spec slug", () => {
+      const id = getNextDecisionId("SPEC-001");
+      expect(id.startsWith("DEC-001-")).toBe(true);
     });
 
-    it("should return sequential IDs", () => {
-      const now = new Date().toISOString();
-      db.run(
-        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
-        ["DEC-001", "SPEC-001", "test", "test", now]
-      );
-      expect(getNextDecisionId("SPEC-001")).toBe("DEC-002");
-
-      db.run(
-        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
-        ["DEC-002", "SPEC-001", "test2", "test2", now]
-      );
-      expect(getNextDecisionId("SPEC-001")).toBe("DEC-003");
+    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 handle gaps in IDs (e.g., DEC-001, DEC-003 → DEC-004)", () => {
-      const now = new Date().toISOString();
-      db.run(
-        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
-        ["DEC-001", "SPEC-001", "test", "test", now]
-      );
-      db.run(
-        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
-        ["DEC-003", "SPEC-001", "test3", "test3", now]
-      );
-      expect(getNextDecisionId("SPEC-001")).toBe("DEC-004");
+    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 scope to spec — different specs have independent IDs", () => {
-      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-002', 'other', 'planning')");
-      const now = new Date().toISOString();
-      db.run(
-        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
-        ["DEC-005", "SPEC-001", "test", "test", now]
-      );
-
-      expect(getNextDecisionId("SPEC-001")).toBe("DEC-006");
-      expect(getNextDecisionId("SPEC-002")).toBe("DEC-001");
+    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);
     });
   });
 
@@ -330,4 +304,457 @@ describe("Migration System", () => {
       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
+    });
+  });
 });