@codexa/cli 9.0.31 → 9.0.32

package/commands/integration.test.ts

@@ -5,66 +5,59 @@
  * between phases, knowledge propagates between tasks, and gates
  * enforce constraints as expected.
  */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { getDb } from "../db/connection";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { cleanDb } from "../db/test-helpers";
-import { planStart, planTaskAdd } from "./plan";
-import { checkRequest, checkApprove } from "./check";
-import { taskStart, taskDone, taskNext } from "./task";
-import { reviewStart, reviewApprove, calculateReviewScore } from "./review";
 import { processSubagentReturn } from "../protocol/process-return";
 import { validateGate } from "../gates/validator";
+import { calculateReviewScore } from "./review";
 
-// Helper: criar spec + tasks diretamente no DB (bypass console.log)
-function setupSpec(name: string, phase: string = "planning"): string {
-  const db = getDb();
+async function setupSpec(name: string, phase: string = "planning"): Promise<string> {
   const id = `test-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
     [id, name, phase, now, now]
   );
-  db.run(
+  await dbRun(
     "INSERT INTO context (spec_id, objective, updated_at) VALUES (?, ?, ?)",
     [id, name, now]
   );
   return id;
 }
 
-function addTask(specId: string, number: number, name: string, agent?: string, dependsOn?: number[]): number {
-  const db = getDb();
+async function addTask(specId: string, number: number, name: string, agent?: string, dependsOn?: number[]): Promise<number> {
   const deps = dependsOn && dependsOn.length > 0 ? JSON.stringify(dependsOn) : null;
-  db.run(
+  await dbRun(
     `INSERT INTO tasks (spec_id, number, name, agent, depends_on, can_parallel, status)
      VALUES (?, ?, ?, ?, ?, 1, 'pending')`,
     [specId, number, name, agent || null, deps]
   );
-  const task = db.query(
-    "SELECT id FROM tasks WHERE spec_id = ? AND number = ?"
-  ).get(specId, number) as any;
+  const task = await dbGet<any>(
+    "SELECT id FROM tasks WHERE spec_id = ? AND number = ?",
+    [specId, number]
+  );
   return task.id;
 }
 
-function approveSpec(specId: string) {
-  const db = getDb();
+async function approveSpec(specId: string) {
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     "UPDATE specs SET phase = 'implementing', approved_at = ?, updated_at = ? WHERE id = ?",
     [now, now, specId]
   );
 }
 
-function startTask(taskId: number) {
-  const db = getDb();
+async function startTask(taskId: number) {
   const now = new Date().toISOString();
-  db.run("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [now, taskId]);
+  await dbRun("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [now, taskId]);
 }
 
-function completeTask(taskId: number, checkpoint: string) {
-  const db = getDb();
+async function completeTask(taskId: number, checkpoint: string) {
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     "UPDATE tasks SET status = 'done', checkpoint = ?, completed_at = ? WHERE id = ?",
     [checkpoint, now, taskId]
   );
@@ -74,48 +67,48 @@ function completeTask(taskId: number, checkpoint: string) {
 // Tests
 // ============================================================
 
-beforeEach(() => {
-  initSchema();
-  cleanDb();
+beforeEach(async () => {
+  const client = createClient({ url: ":memory:" });
+  setClient(client);
+  await initSchema();
+  await cleanDb();
 });
 
-describe("PLAN → CHECK → IMP → REV lifecycle", () => {
-  it("should complete full lifecycle with knowledge propagation", () => {
-    const db = getDb();
+afterEach(() => {
+  resetClient();
+});
 
+describe("PLAN → CHECK → IMP → REV lifecycle", () => {
+  it("should complete full lifecycle with knowledge propagation", async () => {
     // ──── PLAN ────
-    const specId = setupSpec("E2E Test Feature");
-    const task1Id = addTask(specId, 1, "Setup database schema", "backend-javascript");
-    const task2Id = addTask(specId, 2, "Create API endpoints", "backend-javascript", [1]);
+    const specId = await setupSpec("E2E Test Feature");
+    const task1Id = await addTask(specId, 1, "Setup database schema", "backend-javascript");
+    const task2Id = await addTask(specId, 2, "Create API endpoints", "backend-javascript", [1]);
 
-    // Update task count in context
-    db.run("UPDATE context SET total_tasks = 2, updated_at = ? WHERE spec_id = ?", [
+    await dbRun("UPDATE context SET total_tasks = 2, updated_at = ? WHERE spec_id = ?", [
       new Date().toISOString(), specId,
     ]);
 
-    // Verify plan exists
-    const spec = db.query("SELECT * FROM specs WHERE id = ?").get(specId) as any;
+    const spec = await dbGet<any>("SELECT * FROM specs WHERE id = ?", [specId]);
     expect(spec.phase).toBe("planning");
 
     // ──── CHECK ────
-    // Move to checking phase, then approve
-    db.run("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
+    await dbRun("UPDATE specs SET phase = 'checking', updated_at = ? WHERE id = ?", [
       new Date().toISOString(), specId,
     ]);
-    approveSpec(specId);
+    await approveSpec(specId);
 
-    const approvedSpec = db.query("SELECT * FROM specs WHERE id = ?").get(specId) as any;
+    const approvedSpec = await dbGet<any>("SELECT * FROM specs WHERE id = ?", [specId]);
     expect(approvedSpec.phase).toBe("implementing");
     expect(approvedSpec.approved_at).toBeTruthy();
 
     // ──── IMP Task 1 ────
-    startTask(task1Id);
+    await startTask(task1Id);
 
-    const runningTask = db.query("SELECT * FROM tasks WHERE id = ?").get(task1Id) as any;
+    const runningTask = await dbGet<any>("SELECT * FROM tasks WHERE id = ?", [task1Id]);
     expect(runningTask.status).toBe("running");
     expect(runningTask.started_at).toBeTruthy();
 
-    // Simulate subagent return for task 1
     const subagentReturn1 = {
       status: "completed" as const,
       summary: "Created database schema with users and sessions tables",
@@ -148,20 +141,19 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
       ],
     };
 
-    const processResult1 = processSubagentReturn(specId, task1Id, 1, subagentReturn1);
+    const processResult1 = await processSubagentReturn(specId, task1Id, 1, subagentReturn1);
     expect(processResult1.success).toBe(true);
     expect(processResult1.knowledgeAdded).toBe(2);
     expect(processResult1.decisionsAdded).toBe(1);
     expect(processResult1.artifactsAdded).toBe(2);
-    expect(processResult1.reasoningAdded).toBeGreaterThanOrEqual(3); // approach + challenge + alternative + recommendation
+    expect(processResult1.reasoningAdded).toBeGreaterThanOrEqual(3);
 
-    // Complete task 1
-    completeTask(task1Id, "Created database schema with users and sessions tables");
+    await completeTask(task1Id, "Created database schema with users and sessions tables");
 
-    // Verify knowledge was stored
-    const knowledge = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ? ORDER BY created_at"
-    ).all(specId) as any[];
+    const knowledge = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ? ORDER BY created_at",
+      [specId]
+    );
     expect(knowledge.length).toBeGreaterThanOrEqual(2);
 
     const warningKnowledge = knowledge.find(
@@ -169,39 +161,37 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
     );
     expect(warningKnowledge).toBeTruthy();
 
-    // Verify decisions were stored
-    const decisions = db.query(
-      "SELECT * FROM decisions WHERE spec_id = ?"
-    ).all(specId) as any[];
+    const decisions = await dbAll<any>(
+      "SELECT * FROM decisions WHERE spec_id = ?",
+      [specId]
+    );
     expect(decisions.length).toBe(1);
     expect(decisions[0].title).toBe("Database ORM choice");
 
-    // Verify artifacts were stored
-    const artifacts = db.query(
-      "SELECT * FROM artifacts WHERE spec_id = ?"
-    ).all(specId) as any[];
+    const artifacts = await dbAll<any>(
+      "SELECT * FROM artifacts WHERE spec_id = ?",
+      [specId]
+    );
     expect(artifacts.length).toBe(2);
 
-    // Verify reasoning was logged
-    const reasoning = db.query(
-      "SELECT * FROM reasoning_log WHERE spec_id = ? AND task_id = ?"
-    ).all(specId, task1Id) as any[];
+    const reasoning = await dbAll<any>(
+      "SELECT * FROM reasoning_log WHERE spec_id = ? AND task_id = ?",
+      [specId, task1Id]
+    );
     expect(reasoning.length).toBeGreaterThanOrEqual(3);
 
-    // Verify knowledge graph relations
-    const relations = db.query(
-      "SELECT * FROM knowledge_graph WHERE spec_id = ?"
-    ).all(specId) as any[];
+    const relations = await dbAll<any>(
+      "SELECT * FROM knowledge_graph WHERE spec_id = ?",
+      [specId]
+    );
     expect(relations.length).toBeGreaterThan(0);
 
     // ──── IMP Task 2 ────
-    // Task 2 depends on task 1 — verify dependencies gate passes
-    const task1Done = db.query("SELECT status FROM tasks WHERE id = ?").get(task1Id) as any;
+    const task1Done = await dbGet<any>("SELECT status FROM tasks WHERE id = ?", [task1Id]);
     expect(task1Done.status).toBe("done");
 
-    startTask(task2Id);
+    await startTask(task2Id);
 
-    // Simulate subagent return for task 2
     const subagentReturn2 = {
       status: "completed" as const,
       summary: "Created REST API endpoints for users CRUD with authentication",
@@ -219,48 +209,43 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
       ],
     };
 
-    const processResult2 = processSubagentReturn(specId, task2Id, 2, subagentReturn2);
+    const processResult2 = await processSubagentReturn(specId, task2Id, 2, subagentReturn2);
     expect(processResult2.success).toBe(true);
-    expect(processResult2.artifactsAdded).toBe(3); // 2 created + 1 modified (OR REPLACE)
+    expect(processResult2.artifactsAdded).toBe(3);
 
-    completeTask(task2Id, "Created REST API endpoints for users CRUD with authentication");
+    await completeTask(task2Id, "Created REST API endpoints for users CRUD with authentication");
 
-    // Verify total knowledge accumulated from both tasks
-    const allKnowledge = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ?"
-    ).all(specId) as any[];
-    expect(allKnowledge.length).toBeGreaterThanOrEqual(3); // 2 from task 1 + 1 from task 2
+    const allKnowledge = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ?",
+      [specId]
+    );
+    expect(allKnowledge.length).toBeGreaterThanOrEqual(3);
 
     // ──── REV ────
-    // Move to reviewing phase
-    db.run("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [
+    await dbRun("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [
       new Date().toISOString(), specId,
     ]);
 
-    // Calculate review score
-    const score = calculateReviewScore(specId);
+    const score = await calculateReviewScore(specId);
     expect(score.total).toBeGreaterThanOrEqual(50);
-    expect(score.breakdown.tasksCompleted).toBe(25); // All tasks done = full marks
+    expect(score.breakdown.tasksCompleted).toBe(25);
 
-    // Verify all tasks are done
-    const pendingTasks = db.query(
-      "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status != 'done'"
-    ).get(specId) as any;
+    const pendingTasks = await dbGet<any>(
+      "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status != 'done'",
+      [specId]
+    );
     expect(pendingTasks.c).toBe(0);
   });
 
-  it("should propagate knowledge from task 1 to task 2 context", () => {
-    const db = getDb();
+  it("should propagate knowledge from task 1 to task 2 context", async () => {
+    const specId = await setupSpec("Knowledge Propagation Test");
+    const task1Id = await addTask(specId, 1, "First task", "backend-javascript");
+    const task2Id = await addTask(specId, 2, "Second task", "backend-javascript", [1]);
 
-    const specId = setupSpec("Knowledge Propagation Test");
-    const task1Id = addTask(specId, 1, "First task", "backend-javascript");
-    const task2Id = addTask(specId, 2, "Second task", "backend-javascript", [1]);
+    await approveSpec(specId);
+    await startTask(task1Id);
 
-    approveSpec(specId);
-    startTask(task1Id);
-
-    // Task 1 broadcasts critical knowledge
-    processSubagentReturn(specId, task1Id, 1, {
+    await processSubagentReturn(specId, task1Id, 1, {
       status: "completed",
       summary: "Completed first task with important discovery",
       files_created: ["src/first.ts"],
@@ -274,34 +259,31 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
         },
       ],
     });
-    completeTask(task1Id, "Done with first task");
+    await completeTask(task1Id, "Done with first task");
 
-    // Verify knowledge exists
-    const criticalKnowledge = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ? AND severity = 'critical'"
-    ).all(specId) as any[];
+    const criticalKnowledge = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND severity = 'critical'",
+      [specId]
+    );
     expect(criticalKnowledge.length).toBeGreaterThanOrEqual(1);
     expect(criticalKnowledge[0].content).toContain("X-Auth header");
 
-    // Knowledge should be visible for task 2
-    const task2Knowledge = db.query(
-      `SELECT * FROM knowledge WHERE spec_id = ? AND task_origin = ?`
-    ).all(specId, task1Id) as any[];
+    const task2Knowledge = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND task_origin = ?",
+      [specId, task1Id]
+    );
     expect(task2Knowledge.length).toBeGreaterThanOrEqual(1);
   });
 
-  it("should deduplicate identical knowledge entries", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Dedup Test");
-    const task1Id = addTask(specId, 1, "Task 1", "backend-javascript");
-    const task2Id = addTask(specId, 2, "Task 2", "backend-javascript");
+  it("should deduplicate identical knowledge entries", async () => {
+    const specId = await setupSpec("Dedup Test");
+    const task1Id = await addTask(specId, 1, "Task 1", "backend-javascript");
+    const task2Id = await addTask(specId, 2, "Task 2", "backend-javascript");
 
-    approveSpec(specId);
+    await approveSpec(specId);
 
-    // Both tasks broadcast the same knowledge
-    startTask(task1Id);
-    processSubagentReturn(specId, task1Id, 1, {
+    await startTask(task1Id);
+    await processSubagentReturn(specId, task1Id, 1, {
       status: "completed",
       summary: "First task done",
       files_created: ["src/a.ts"],
@@ -311,10 +293,10 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
         { category: "discovery", content: "Uses UTF-8 encoding everywhere", severity: "info" },
       ],
     });
-    completeTask(task1Id, "Done");
+    await completeTask(task1Id, "Done");
 
-    startTask(task2Id);
-    processSubagentReturn(specId, task2Id, 2, {
+    await startTask(task2Id);
+    await processSubagentReturn(specId, task2Id, 2, {
       status: "completed",
       summary: "Second task done",
       files_created: ["src/b.ts"],
@@ -324,27 +306,24 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
         { category: "discovery", content: "Uses UTF-8 encoding everywhere", severity: "info" },
       ],
     });
-    completeTask(task2Id, "Done");
+    await completeTask(task2Id, "Done");
 
-    // Should only have 1 entry (deduplicated)
-    const entries = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ? AND content = 'Uses UTF-8 encoding everywhere'"
-    ).all(specId) as any[];
+    const entries = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND content = 'Uses UTF-8 encoding everywhere'",
+      [specId]
+    );
     expect(entries.length).toBe(1);
   });
 
-  it("should register decisions and detect conflicts", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Decision Conflict Test");
-    const task1Id = addTask(specId, 1, "Task 1", "backend-javascript");
-    const task2Id = addTask(specId, 2, "Task 2", "backend-javascript");
+  it("should register decisions and detect conflicts", async () => {
+    const specId = await setupSpec("Decision Conflict Test");
+    const task1Id = await addTask(specId, 1, "Task 1", "backend-javascript");
+    const task2Id = await addTask(specId, 2, "Task 2", "backend-javascript");
 
-    approveSpec(specId);
+    await approveSpec(specId);
 
-    // Task 1 decides to use Prisma
-    startTask(task1Id);
-    processSubagentReturn(specId, task1Id, 1, {
+    await startTask(task1Id);
+    await processSubagentReturn(specId, task1Id, 1, {
       status: "completed",
       summary: "Setup database with Prisma ORM for type-safe database access",
       files_created: ["prisma/schema.prisma"],
@@ -354,45 +333,40 @@ describe("PLAN → CHECK → IMP → REV lifecycle", () => {
         { title: "ORM Selection", decision: "Use Prisma ORM", rationale: "Best TypeScript integration" },
       ],
     });
-    completeTask(task1Id, "Done with Prisma setup");
+    await completeTask(task1Id, "Done with Prisma setup");
 
-    // Verify decision saved
-    const decisions = db.query(
-      "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'"
-    ).all(specId) as any[];
+    const decisions = await dbAll<any>(
+      "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'",
+      [specId]
+    );
     expect(decisions.length).toBe(1);
     expect(decisions[0].decision).toContain("Prisma");
   });
 });
 
 describe("Gate enforcement", () => {
-  it("should block task-done without checkpoint", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Gate Test");
-    const taskId = addTask(specId, 1, "Test task");
-    approveSpec(specId);
-    startTask(taskId);
+  it("should block task-done without checkpoint", async () => {
+    const specId = await setupSpec("Gate Test");
+    const taskId = await addTask(specId, 1, "Test task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const result = validateGate("task-done", {
+    const result = await validateGate("task-done", {
       taskId,
-      checkpoint: "short",  // < 10 chars
+      checkpoint: "short",
       files: [],
     });
     expect(result.passed).toBe(false);
     expect(result.reason).toContain("Checkpoint");
   });
 
-  it("should block task-start when dependencies are not done", () => {
-    const db = getDb();
+  it("should block task-start when dependencies are not done", async () => {
+    const specId = await setupSpec("Dependency Gate Test");
+    const task1Id = await addTask(specId, 1, "First task");
+    const task2Id = await addTask(specId, 2, "Second task", undefined, [1]);
+    await approveSpec(specId);
 
-    const specId = setupSpec("Dependency Gate Test");
-    const task1Id = addTask(specId, 1, "First task");
-    const task2Id = addTask(specId, 2, "Second task", undefined, [1]);
-    approveSpec(specId);
-
-    // Task 1 is still pending
-    const result = validateGate("task-start", {
+    const result = await validateGate("task-start", {
       taskId: task2Id,
       specId,
     });
@@ -400,53 +374,50 @@ describe("Gate enforcement", () => {
     expect(result.reason).toContain("Dependencias");
   });
 
-  it("should pass task-start when dependencies are done", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Dependency Pass Test");
-    const task1Id = addTask(specId, 1, "First task");
-    const task2Id = addTask(specId, 2, "Second task", undefined, [1]);
-    approveSpec(specId);
+  it("should pass task-start when dependencies are done", async () => {
+    const specId = await setupSpec("Dependency Pass Test");
+    const task1Id = await addTask(specId, 1, "First task");
+    const task2Id = await addTask(specId, 2, "Second task", undefined, [1]);
+    await approveSpec(specId);
 
-    // Complete task 1
-    startTask(task1Id);
-    completeTask(task1Id, "First task completed successfully");
+    await startTask(task1Id);
+    await completeTask(task1Id, "First task completed successfully");
 
-    const result = validateGate("task-start", {
+    const result = await validateGate("task-start", {
       taskId: task2Id,
       specId,
     });
     expect(result.passed).toBe(true);
   });
 
-  it("should block review-start when tasks are pending", () => {
-    const specId = setupSpec("Review Gate Test");
-    addTask(specId, 1, "Incomplete task");
-    approveSpec(specId);
+  it("should block review-start when tasks are pending", async () => {
+    const specId = await setupSpec("Review Gate Test");
+    await addTask(specId, 1, "Incomplete task");
+    await approveSpec(specId);
 
-    const result = validateGate("review-start", { specId });
+    const result = await validateGate("review-start", { specId });
     expect(result.passed).toBe(false);
     expect(result.reason).toContain("Tasks pendentes");
   });
 
-  it("should pass review-start when all tasks are done", () => {
-    const specId = setupSpec("Review Pass Test");
-    const taskId = addTask(specId, 1, "Only task");
-    approveSpec(specId);
-    startTask(taskId);
-    completeTask(taskId, "Completed the only task successfully");
+  it("should pass review-start when all tasks are done", async () => {
+    const specId = await setupSpec("Review Pass Test");
+    const taskId = await addTask(specId, 1, "Only task");
+    await approveSpec(specId);
+    await startTask(taskId);
+    await completeTask(taskId, "Completed the only task successfully");
 
-    const result = validateGate("review-start", { specId });
+    const result = await validateGate("review-start", { specId });
     expect(result.passed).toBe(true);
   });
 
-  it("should require reasoning for completed subagent returns", () => {
-    const specId = setupSpec("Reasoning Gate Test");
-    const taskId = addTask(specId, 1, "Reasoning task");
-    approveSpec(specId);
-    startTask(taskId);
+  it("should require reasoning for completed subagent returns", async () => {
+    const specId = await setupSpec("Reasoning Gate Test");
+    const taskId = await addTask(specId, 1, "Reasoning task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const result = validateGate("task-done", {
+    const result = await validateGate("task-done", {
       taskId,
       checkpoint: "This is a valid checkpoint text",
       files: [],
@@ -455,7 +426,7 @@ describe("Gate enforcement", () => {
         summary: "Done",
         files_created: [],
         files_modified: [],
-        reasoning: { approach: "short" },  // < 20 chars
+        reasoning: { approach: "short" },
       },
     });
     expect(result.passed).toBe(false);
@@ -464,13 +435,13 @@ describe("Gate enforcement", () => {
 });
 
 describe("files-exist gate with sandbox", () => {
-  it("should pass when subagent reports files that dont exist on disk", () => {
-    const specId = setupSpec("Sandbox Files Test");
-    const taskId = addTask(specId, 1, "Sandbox task");
-    approveSpec(specId);
-    startTask(taskId);
+  it("should pass when subagent reports files that dont exist on disk", async () => {
+    const specId = await setupSpec("Sandbox Files Test");
+    const taskId = await addTask(specId, 1, "Sandbox task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const result = validateGate("task-done", {
+    const result = await validateGate("task-done", {
       taskId,
       checkpoint: "Completed sandbox task with new files created",
       files: ["src/sandbox/nonexistent-file.ts"],
@@ -485,36 +456,32 @@ describe("files-exist gate with sandbox", () => {
     expect(result.passed).toBe(true);
   });
 
-  it("should fail when file not on disk and not from subagent", () => {
-    const specId = setupSpec("Missing File Test");
-    const taskId = addTask(specId, 1, "Missing file task");
-    approveSpec(specId);
-    startTask(taskId);
+  it("should fail when file not on disk and not from subagent", async () => {
+    const specId = await setupSpec("Missing File Test");
+    const taskId = await addTask(specId, 1, "Missing file task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const result = validateGate("task-done", {
+    const result = await validateGate("task-done", {
       taskId,
       checkpoint: "Completed missing file task properly",
       files: ["src/this-file-definitely-does-not-exist-xyz.ts"],
-      // No subagentData — file should exist on disk
     });
     expect(result.passed).toBe(false);
     expect(result.reason).toContain("nao encontrado");
   });
 
-  it("should pass when subagent reports mix of existing and sandbox files", () => {
-    const db = getDb();
-    const specId = setupSpec("Mixed Files Test");
-    const taskId = addTask(specId, 1, "Mixed files task");
-    approveSpec(specId);
+  it("should pass when subagent reports mix of existing and sandbox files", async () => {
+    const specId = await setupSpec("Mixed Files Test");
+    const taskId = await addTask(specId, 1, "Mixed files task");
+    await approveSpec(specId);
 
-    // Set started_at far in the past so mtime check passes for existing file
     const pastTime = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString();
-    db.run("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [pastTime, taskId]);
+    await dbRun("UPDATE tasks SET status = 'running', started_at = ? WHERE id = ?", [pastTime, taskId]);
 
-    // Use a file that actually exists (this test file itself)
     const existingFile = import.meta.path;
 
-    const result = validateGate("task-done", {
+    const result = await validateGate("task-done", {
       taskId,
       checkpoint: "Completed mixed files task with both types",
       files: [existingFile, "src/sandbox/new-file.ts"],
@@ -526,79 +493,69 @@ describe("files-exist gate with sandbox", () => {
         reasoning: { approach: "Modified existing file and created new file for component" },
       },
     });
-    // The existing file passes validation, the sandbox file is trusted via subagent
     expect(result.passed).toBe(true);
   });
 });
 
 describe("Review scoring", () => {
-  it("should calculate perfect score when all tasks done and no bypasses", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Perfect Score Test");
-    const task1Id = addTask(specId, 1, "Task 1");
-    const task2Id = addTask(specId, 2, "Task 2");
-    approveSpec(specId);
-
-    // Complete both tasks
-    startTask(task1Id);
-    completeTask(task1Id, "Task 1 done perfectly");
-    startTask(task2Id);
-    completeTask(task2Id, "Task 2 done perfectly");
-
-    // Register some artifacts
-    db.run(
+  it("should calculate perfect score when all tasks done and no bypasses", async () => {
+    const specId = await setupSpec("Perfect Score Test");
+    const task1Id = await addTask(specId, 1, "Task 1");
+    const task2Id = await addTask(specId, 2, "Task 2");
+    await approveSpec(specId);
+
+    await startTask(task1Id);
+    await completeTask(task1Id, "Task 1 done perfectly");
+    await startTask(task2Id);
+    await completeTask(task2Id, "Task 2 done perfectly");
+
+    await dbRun(
       "INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 1, 'src/a.ts', 'created')",
       [specId]
     );
-    db.run(
+    await dbRun(
       "INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, 2, 'src/b.ts', 'created')",
       [specId]
     );
 
-    const score = calculateReviewScore(specId);
+    const score = await calculateReviewScore(specId);
     expect(score.breakdown.tasksCompleted).toBe(25);
     expect(score.breakdown.gatesPassedClean).toBe(25);
     expect(score.breakdown.standardsFollowed).toBe(25);
-    expect(score.total).toBeGreaterThanOrEqual(75); // files_delivered depends on planned vs created
+    expect(score.total).toBeGreaterThanOrEqual(75);
     expect(score.autoApproveEligible).toBe(true);
     expect(score.mustReviewItems.length).toBe(0);
   });
 
-  it("should reduce score when gates are bypassed", () => {
-    const db = getDb();
-
-    const specId = setupSpec("Bypass Score Test");
-    const taskId = addTask(specId, 1, "Bypassed task");
-    approveSpec(specId);
+  it("should reduce score when gates are bypassed", async () => {
+    const specId = await setupSpec("Bypass Score Test");
+    const taskId = await addTask(specId, 1, "Bypassed task");
+    await approveSpec(specId);
 
-    startTask(taskId);
-    completeTask(taskId, "Done with bypasses");
+    await startTask(taskId);
+    await completeTask(taskId, "Done with bypasses");
 
-    // Register a critical bypass
-    db.run(
+    await dbRun(
       "INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason) VALUES (?, ?, 'standards-follow', 'Test bypass')",
       [specId, taskId]
     );
 
-    const score = calculateReviewScore(specId);
+    const score = await calculateReviewScore(specId);
     expect(score.breakdown.gatesPassedClean).toBeLessThan(25);
     expect(score.breakdown.standardsFollowed).toBeLessThan(25);
-    expect(score.autoApproveEligible).toBe(false); // Critical bypass
+    expect(score.autoApproveEligible).toBe(false);
     expect(score.mustReviewItems.length).toBeGreaterThan(0);
   });
 });
 
 describe("processSubagentReturn", () => {
-  it("should handle blocked status with blockers as critical knowledge", () => {
-    const db = getDb();
+  it("should handle blocked status with blockers as critical knowledge", async () => {
+    const specId = await setupSpec("Blocked Task Test");
+    const taskId = await addTask(specId, 1, "Blocked task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const specId = setupSpec("Blocked Task Test");
-    const taskId = addTask(specId, 1, "Blocked task");
-    approveSpec(specId);
-    startTask(taskId);
-
-    const result = processSubagentReturn(specId, taskId, 1, {
+    const result = await processSubagentReturn(specId, taskId, 1, {
       status: "blocked",
       summary: "Blocked by missing API key configuration",
       files_created: [],
@@ -612,22 +569,20 @@ describe("processSubagentReturn", () => {
     expect(result.knowledgeAdded).toBe(2);
     expect(result.artifactsAdded).toBe(0);
 
-    // Verify blockers stored as critical knowledge
-    const blockers = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ? AND category = 'blocker' AND severity = 'critical'"
-    ).all(specId) as any[];
+    const blockers = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ? AND category = 'blocker' AND severity = 'critical'",
+      [specId]
+    );
     expect(blockers.length).toBe(2);
   });
 
-  it("should store all artifacts from files_created and files_modified", () => {
-    const db = getDb();
+  it("should store all artifacts from files_created and files_modified", async () => {
+    const specId = await setupSpec("Artifacts Test");
+    const taskId = await addTask(specId, 1, "Artifact task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const specId = setupSpec("Artifacts Test");
-    const taskId = addTask(specId, 1, "Artifact task");
-    approveSpec(specId);
-    startTask(taskId);
-
-    const result = processSubagentReturn(specId, taskId, 1, {
+    const result = await processSubagentReturn(specId, taskId, 1, {
       status: "completed",
       summary: "Created and modified multiple files for the feature",
       files_created: ["src/new1.ts", "src/new2.ts"],
@@ -637,9 +592,10 @@ describe("processSubagentReturn", () => {
 
     expect(result.artifactsAdded).toBe(3);
 
-    const artifacts = db.query(
-      "SELECT * FROM artifacts WHERE spec_id = ? ORDER BY path"
-    ).all(specId) as any[];
+    const artifacts = await dbAll<any>(
+      "SELECT * FROM artifacts WHERE spec_id = ? ORDER BY path",
+      [specId]
+    );
     expect(artifacts.length).toBe(3);
 
     const created = artifacts.filter((a: any) => a.action === "created");
@@ -648,15 +604,13 @@ describe("processSubagentReturn", () => {
     expect(modified.length).toBe(1);
   });
 
-  it("should build knowledge graph relations", () => {
-    const db = getDb();
+  it("should build knowledge graph relations", async () => {
+    const specId = await setupSpec("Graph Test");
+    const taskId = await addTask(specId, 1, "Graph task");
+    await approveSpec(specId);
+    await startTask(taskId);
 
-    const specId = setupSpec("Graph Test");
-    const taskId = addTask(specId, 1, "Graph task");
-    approveSpec(specId);
-    startTask(taskId);
-
-    processSubagentReturn(specId, taskId, 1, {
+    await processSubagentReturn(specId, taskId, 1, {
       status: "completed",
       summary: "Created files with patterns for the component",
       files_created: ["src/api.ts"],
@@ -665,12 +619,11 @@ describe("processSubagentReturn", () => {
       patterns_discovered: ["REST endpoint pattern"],
     });
 
-    const relations = db.query(
-      "SELECT * FROM knowledge_graph WHERE spec_id = ?"
-    ).all(specId) as any[];
+    const relations = await dbAll<any>(
+      "SELECT * FROM knowledge_graph WHERE spec_id = ?",
+      [specId]
+    );
 
-    // Should have: task->api.ts(creates), task->config.ts(modifies),
-    //              pattern->api.ts(extracted_from)
     const creates = relations.filter((r: any) => r.relation === "creates");
     const modifies = relations.filter((r: any) => r.relation === "modifies");
     const extracted = relations.filter((r: any) => r.relation === "extracted_from");
@@ -682,42 +635,36 @@ describe("processSubagentReturn", () => {
 });
 
 describe("Multi-spec parallel", () => {
-  it("should allow multiple specs to coexist", () => {
-    const db = getDb();
+  it("should allow multiple specs to coexist", async () => {
+    const specA = await setupSpec("Feature A");
+    const specB = await setupSpec("Feature B");
 
-    const specA = setupSpec("Feature A");
-    const specB = setupSpec("Feature B");
+    await addTask(specA, 1, "Task A1");
+    await addTask(specB, 1, "Task B1");
 
-    addTask(specA, 1, "Task A1");
-    addTask(specB, 1, "Task B1");
-
-    // Both should exist
-    const specs = db.query(
+    const specs = await dbAll<any>(
       "SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled')"
-    ).all() as any[];
+    );
     expect(specs.length).toBe(2);
 
-    // Tasks should be isolated per spec
-    const tasksA = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(specA) as any[];
-    const tasksB = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(specB) as any[];
+    const tasksA = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ?", [specA]);
+    const tasksB = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ?", [specB]);
     expect(tasksA.length).toBe(1);
     expect(tasksB.length).toBe(1);
   });
 
-  it("should isolate knowledge per spec", () => {
-    const db = getDb();
-
-    const specA = setupSpec("Feature A");
-    const specB = setupSpec("Feature B");
-    const taskA = addTask(specA, 1, "Task A1");
-    const taskB = addTask(specB, 1, "Task B1");
+  it("should isolate knowledge per spec", async () => {
+    const specA = await setupSpec("Feature A");
+    const specB = await setupSpec("Feature B");
+    const taskA = await addTask(specA, 1, "Task A1");
+    const taskB = await addTask(specB, 1, "Task B1");
 
-    approveSpec(specA);
-    approveSpec(specB);
-    startTask(taskA);
-    startTask(taskB);
+    await approveSpec(specA);
+    await approveSpec(specB);
+    await startTask(taskA);
+    await startTask(taskB);
 
-    processSubagentReturn(specA, taskA, 1, {
+    await processSubagentReturn(specA, taskA, 1, {
       status: "completed",
       summary: "Done with Feature A task and found important info",
       files_created: ["src/a.ts"],
@@ -728,7 +675,7 @@ describe("Multi-spec parallel", () => {
       ],
     });
 
-    processSubagentReturn(specB, taskB, 1, {
+    await processSubagentReturn(specB, taskB, 1, {
       status: "completed",
       summary: "Done with Feature B task and found other info",
       files_created: ["src/b.ts"],
@@ -739,12 +686,14 @@ describe("Multi-spec parallel", () => {
       ],
     });
 
-    const knowledgeA = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ?"
-    ).all(specA) as any[];
-    const knowledgeB = db.query(
-      "SELECT * FROM knowledge WHERE spec_id = ?"
-    ).all(specB) as any[];
+    const knowledgeA = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ?",
+      [specA]
+    );
+    const knowledgeB = await dbAll<any>(
+      "SELECT * FROM knowledge WHERE spec_id = ?",
+      [specB]
+    );
 
     expect(knowledgeA.length).toBeGreaterThanOrEqual(1);
     expect(knowledgeB.length).toBeGreaterThanOrEqual(1);