@codexa/cli 9.0.30 → 9.0.32

package/commands/review.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { enforceGate } from "../gates/validator";
 import { resolveSpec } from "./spec-resolver";
@@ -22,18 +22,22 @@ export interface ReviewScore {
   mustReviewItems: string[];     // Items que exigem atencao humana
 }
 
-export function calculateReviewScore(specId: string): ReviewScore {
-  const db = getDb();
-
+export async function calculateReviewScore(specId: string): Promise<ReviewScore> {
   const mustReviewItems: string[] = [];
 
   // 1. Tasks: (completed / total) * 25
-  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 totalTasksRow = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?",
+    [specId]
+  );
+  const totalTasks = totalTasksRow?.c ?? 0;
+
+  const completedTasksRow = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'",
+    [specId]
+  );
+  const completedTasks = completedTasksRow?.c ?? 0;
+
   const tasksCompleted = totalTasks > 0
     ? Math.round((completedTasks / totalTasks) * 25)
     : 25;
@@ -45,26 +49,30 @@ export function calculateReviewScore(specId: string): ReviewScore {
   // 2. Gates: (clean passes / total gate events) * 25
   // Total gate events = tasks * 7 gates per task
   const totalGateEvents = totalTasks * 7;
-  const bypassCount = (db.query(
-    "SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ?"
-  ).get(specId) as any).c;
+  const bypassCountRow = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ?",
+    [specId]
+  );
+  const bypassCount = bypassCountRow?.c ?? 0;
   const cleanGateEvents = Math.max(0, totalGateEvents - bypassCount);
   const gatesPassedClean = totalGateEvents > 0
     ? Math.round((cleanGateEvents / totalGateEvents) * 25)
     : 25;
 
   // Check for critical bypasses
-  const criticalBypasses = db.query(
-    "SELECT * FROM gate_bypasses WHERE spec_id = ? AND gate_name IN ('standards-follow', 'dry-check', 'typecheck-pass')"
-  ).all(specId) as any[];
+  const criticalBypasses = await dbAll<any>(
+    "SELECT * FROM gate_bypasses WHERE spec_id = ? AND gate_name IN ('standards-follow', 'dry-check', 'typecheck-pass')",
+    [specId]
+  );
   if (criticalBypasses.length > 0) {
     mustReviewItems.push(`${criticalBypasses.length} bypass(es) de gates criticos`);
   }
 
   // 3. Files: (delivered / planned) * 25
-  const plannedFiles = db.query(
-    "SELECT files FROM tasks WHERE spec_id = ? AND files IS NOT NULL"
-  ).all(specId) as any[];
+  const plannedFiles = await dbAll<any>(
+    "SELECT files FROM tasks WHERE spec_id = ? AND files IS NOT NULL",
+    [specId]
+  );
   const allPlannedFiles = new Set<string>();
   for (const t of plannedFiles) {
     try {
@@ -73,11 +81,11 @@ export function calculateReviewScore(specId: string): ReviewScore {
     } catch { /* ignore */ }
   }
 
-  const deliveredFiles = new Set(
-    (db.query(
-      "SELECT DISTINCT path FROM artifacts WHERE spec_id = ?"
-    ).all(specId) as any[]).map(a => a.path)
+  const deliveredArtifacts = await dbAll<any>(
+    "SELECT DISTINCT path FROM artifacts WHERE spec_id = ?",
+    [specId]
   );
+  const deliveredFiles = new Set(deliveredArtifacts.map(a => a.path));
 
   let filesDelivered: number;
   if (allPlannedFiles.size === 0) {
@@ -97,9 +105,11 @@ export function calculateReviewScore(specId: string): ReviewScore {
 
   // 4. Standards: (followed / total) * 25
   // Inverse of standards-follow bypasses relative to total tasks
-  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 standardsBypassesRow = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ? AND gate_name = 'standards-follow'",
+    [specId]
+  );
+  const standardsBypasses = standardsBypassesRow?.c ?? 0;
   const standardsFollowed = totalTasks > 0
     ? Math.round(((totalTasks - standardsBypasses) / totalTasks) * 25)
     : 25;
@@ -124,32 +134,35 @@ export function calculateReviewScore(specId: string): ReviewScore {
   };
 }
 
-export function reviewStart(json: boolean = false, specId?: string): void {
-  initSchema();
+export async function reviewStart(json: boolean = false, specId?: string): Promise<void> {
+  await initSchema();
   enforceGate("review-start");
 
-  const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = resolveSpec(specId, ["implementing"]);
+  const spec = await resolveSpec(specId, ["implementing"]);
 
-  const tasks = db
-    .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
-    .all(spec.id) as any[];
+  const tasks = await dbAll<any>(
+    "SELECT * FROM tasks WHERE spec_id = ? ORDER BY number",
+    [spec.id]
+  );
 
-  const artifacts = db
-    .query("SELECT * FROM artifacts WHERE spec_id = ?")
-    .all(spec.id) as any[];
+  const artifacts = await dbAll<any>(
+    "SELECT * FROM artifacts WHERE spec_id = ?",
+    [spec.id]
+  );
 
-  const decisions = db
-    .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
-    .all(spec.id) as any[];
+  const decisions = await dbAll<any>(
+    "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'",
+    [spec.id]
+  );
 
   // v8.4: Buscar analise arquitetural (link explicito via analysis_id ou nome)
-  const archAnalysis = getArchitecturalAnalysisForSpec(spec.name, spec.id);
-  const gateBypasses = db.query(
-    "SELECT * FROM gate_bypasses WHERE spec_id = ? ORDER BY created_at"
-  ).all(spec.id) as any[];
+  const archAnalysis = await getArchitecturalAnalysisForSpec(spec.name, spec.id);
+  const gateBypasses = await dbAll<any>(
+    "SELECT * FROM gate_bypasses WHERE spec_id = ? ORDER BY created_at",
+    [spec.id]
+  );
 
   // Analisar plano vs implementado
   const plannedFiles = tasks.flatMap((t) => (t.files ? JSON.parse(t.files) : []));
@@ -166,6 +179,15 @@ export function reviewStart(json: boolean = false, specId?: string): void {
     deviations.push(`Arquivos extras criados: ${extraFiles.join(", ")}`);
   }
 
+  // v8.5: Utilities criadas nesta feature (DRY audit)
+  let utilitiesCreated: any[] = [];
+  try {
+    utilitiesCreated = await dbAll<any>(
+      "SELECT * FROM project_utilities WHERE spec_id = ? ORDER BY file_path",
+      [spec.id]
+    );
+  } catch { utilitiesCreated = []; }
+
   // Criar registro de review
   const reviewData = {
     tasks_completed: tasks.length,
@@ -183,17 +205,10 @@ export function reviewStart(json: boolean = false, specId?: string): void {
       decisions: archAnalysis.decisions ? JSON.parse(archAnalysis.decisions) : [],
     } : null,
     gate_bypasses: gateBypasses,
-    // v8.5: Utilities criadas nesta feature (DRY audit)
-    utilities_created: (() => {
-      try {
-        return db.query(
-          "SELECT * FROM project_utilities WHERE spec_id = ? ORDER BY file_path"
-        ).all(spec.id) as any[];
-      } catch { return []; }
-    })(),
+    utilities_created: utilitiesCreated,
   };
 
-  db.run(
+  await dbRun(
     `INSERT INTO review (spec_id, planned_vs_done, deviations, status, created_at)
      VALUES (?, ?, ?, 'pending', ?)`,
     [
@@ -205,10 +220,10 @@ export function reviewStart(json: boolean = false, specId?: string): void {
   );
 
   // Atualizar fase
-  db.run("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [now, spec.id]);
+  await dbRun("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [now, spec.id]);
 
   // P1-2: Calcular score automatico
-  const score = calculateReviewScore(spec.id);
+  const score = await calculateReviewScore(spec.id);
 
   if (json) {
     console.log(JSON.stringify({ spec, reviewData, deviations, score }));
@@ -284,11 +299,10 @@ export function reviewStart(json: boolean = false, specId?: string): void {
   console.log(`Para ver status: status\n`);
 }
 
-export function reviewApprove(options?: { specId?: string; force?: boolean; forceReason?: string } | string): void {
-  initSchema();
+export async function reviewApprove(options?: { specId?: string; force?: boolean; forceReason?: string } | string): Promise<void> {
+  await initSchema();
   enforceGate("review-approve");
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   // Backward compat: accept string (old API) or options object
@@ -296,10 +310,10 @@ export function reviewApprove(options?: { specId?: string; force?: boolean; forc
     ? { specId: options }
     : (options || {});
 
-  const spec = resolveSpec(opts.specId, ["reviewing"]);
+  const spec = await resolveSpec(opts.specId, ["reviewing"]);
 
   // P1-2: Enforce minimum score
-  const score = calculateReviewScore(spec.id);
+  const score = await calculateReviewScore(spec.id);
   if (score.total < 50 && !opts.force) {
     throw new GateError(
       `Review score muito baixo: ${score.total}/100.\n` +
@@ -312,7 +326,7 @@ export function reviewApprove(options?: { specId?: string; force?: boolean; forc
 
   if (score.total < 50 && opts.force) {
     // Log the forced approval
-    db.run(
+    await dbRun(
       `INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason, created_at)
        VALUES (?, 0, 'review-low-score', ?, ?)`,
       [spec.id, opts.forceReason || `Score ${score.total}/100 - forced approval`, now]
@@ -321,20 +335,20 @@ export function reviewApprove(options?: { specId?: string; force?: boolean; forc
   }
 
   // Atualizar review
-  db.run("UPDATE review SET status = 'passed' WHERE spec_id = ?", [spec.id]);
+  await dbRun("UPDATE review SET status = 'passed' WHERE spec_id = ?", [spec.id]);
 
   // Atualizar spec para completed
-  db.run("UPDATE specs SET phase = 'completed', updated_at = ? WHERE id = ?", [now, spec.id]);
+  await dbRun("UPDATE specs SET phase = 'completed', updated_at = ? WHERE id = ?", [now, spec.id]);
 
 
 
   // Buscar todos os dados para snapshot e relatorio
-  const tasks = db.query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number").all(spec.id) as any[];
-  const decisions = db.query("SELECT * FROM decisions WHERE spec_id = ?").all(spec.id) as any[];
-  const artifacts = db.query("SELECT * FROM artifacts WHERE spec_id = ?").all(spec.id) as any[];
-  const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
-  const review = db.query("SELECT * FROM review WHERE spec_id = ?").get(spec.id) as any;
-  const knowledge = db.query("SELECT * FROM knowledge WHERE spec_id = ?").all(spec.id) as any[];
+  const tasks = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number", [spec.id]);
+  const decisions = await dbAll<any>("SELECT * FROM decisions WHERE spec_id = ?", [spec.id]);
+  const artifacts = await dbAll<any>("SELECT * FROM artifacts WHERE spec_id = ?", [spec.id]);
+  const context = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [spec.id]);
+  const review = await dbGet<any>("SELECT * FROM review WHERE spec_id = ?", [spec.id]);
+  const knowledge = await dbAll<any>("SELECT * FROM knowledge WHERE spec_id = ?", [spec.id]);
 
   // Criar snapshot final
   const allData = {
@@ -347,7 +361,7 @@ export function reviewApprove(options?: { specId?: string; force?: boolean; forc
     knowledge,
   };
 
-  db.run("INSERT INTO snapshots (spec_id, data, trigger, created_at) VALUES (?, ?, 'final', ?)", [
+  await dbRun("INSERT INTO snapshots (spec_id, data, trigger, created_at) VALUES (?, ?, 'final', ?)", [
     spec.id,
     JSON.stringify(allData),
     now,
@@ -360,44 +374,44 @@ export function reviewApprove(options?: { specId?: string; force?: boolean; forc
 /**
  * Pula o review e finaliza a feature diretamente
  */
-export function reviewSkip(specId?: string): void {
-  initSchema();
+export async function reviewSkip(specId?: string): Promise<void> {
+  await initSchema();
 
-  const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = resolveSpec(specId, ["implementing"]);
+  const spec = await resolveSpec(specId, ["implementing"]);
 
   // Verificar se todas tasks estao done
-  const pending = db
-    .query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status != 'done'")
-    .get(spec.id) as any;
+  const pending = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status != 'done'",
+    [spec.id]
+  );
 
-  if (pending.c > 0) {
+  if (pending && pending.c > 0) {
     throw new CodexaError(`Ainda existem ${pending.c} tasks pendentes.\nComplete todas as tasks antes de pular o review.`);
   }
 
   // Buscar dados
-  const tasks = db.query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number").all(spec.id) as any[];
-  const decisions = db.query("SELECT * FROM decisions WHERE spec_id = ?").all(spec.id) as any[];
-  const artifacts = db.query("SELECT * FROM artifacts WHERE spec_id = ?").all(spec.id) as any[];
-  const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
-  const knowledge = db.query("SELECT * FROM knowledge WHERE spec_id = ?").all(spec.id) as any[];
+  const tasks = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number", [spec.id]);
+  const decisions = await dbAll<any>("SELECT * FROM decisions WHERE spec_id = ?", [spec.id]);
+  const artifacts = await dbAll<any>("SELECT * FROM artifacts WHERE spec_id = ?", [spec.id]);
+  const context = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [spec.id]);
+  const knowledge = await dbAll<any>("SELECT * FROM knowledge WHERE spec_id = ?", [spec.id]);
 
   // Criar registro de review como skipped
-  db.run(
+  await dbRun(
     `INSERT INTO review (spec_id, planned_vs_done, deviations, status, created_at)
      VALUES (?, ?, NULL, 'skipped', ?)`,
     [spec.id, JSON.stringify({ skipped: true, reason: "User chose to skip review" }), now]
   );
 
   // Atualizar spec para completed
-  db.run("UPDATE specs SET phase = 'completed', updated_at = ? WHERE id = ?", [now, spec.id]);
+  await dbRun("UPDATE specs SET phase = 'completed', updated_at = ? WHERE id = ?", [now, spec.id]);
 
 
 
   // Criar snapshot final
-  const review = db.query("SELECT * FROM review WHERE spec_id = ?").get(spec.id) as any;
+  const review = await dbGet<any>("SELECT * FROM review WHERE spec_id = ?", [spec.id]);
   const allData = {
     spec,
     context,
@@ -408,7 +422,7 @@ export function reviewSkip(specId?: string): void {
     knowledge,
   };
 
-  db.run("INSERT INTO snapshots (spec_id, data, trigger, created_at) VALUES (?, ?, 'final', ?)", [
+  await dbRun("INSERT INTO snapshots (spec_id, data, trigger, created_at) VALUES (?, ?, 'final', ?)", [
     spec.id,
     JSON.stringify(allData),
     now,

package/commands/simplify.ts

@@ -4,7 +4,7 @@
 // Used post-task (Option A) and pre-review (Option C).
 // ═══════════════════════════════════════════════════════════════
 
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { resolveSpec } from "./spec-resolver";
 import { getAgentDomain, domainToScope } from "../context/domains";
@@ -20,15 +20,14 @@ import {
 // SIMPLIFY FOR TASK (Option A)
 // ═══════════════════════════════════════════════════════════════
 
-export function simplifyTask(
+export async function simplifyTask(
   taskId: string,
   options: { audit?: boolean; specId?: string } = {}
-): void {
-  initSchema();
+): Promise<void> {
+  await initSchema();
 
-  const db = getDb();
   const id = parseInt(taskId);
-  const task = db.query("SELECT * FROM tasks WHERE id = ?").get(id) as any;
+  const task = await dbGet<any>("SELECT * FROM tasks WHERE id = ?", [id]);
 
   if (!task) {
     throw new CodexaError(`Task #${id} nao encontrada.`);
@@ -40,12 +39,10 @@ export function simplifyTask(
     );
   }
 
-  // Get files from artifacts
-  const artifacts = db
-    .query(
-      "SELECT path, action FROM artifacts WHERE spec_id = ? AND task_ref = ?"
-    )
-    .all(task.spec_id, task.number) as any[];
+  const artifacts = await dbAll<any>(
+    "SELECT path, action FROM artifacts WHERE spec_id = ? AND task_ref = ?",
+    [task.spec_id, task.number]
+  );
 
   if (artifacts.length === 0) {
     console.log(`\nTask #${task.number} nao tem arquivos registrados. Nada para simplificar.\n`);
@@ -57,18 +54,14 @@ export function simplifyTask(
     action: a.action === "created" ? "created" as const : "modified" as const,
   }));
 
-  // Determine agent domain for scope filtering
   const domain = getAgentDomain(task.agent);
   const scope = domainToScope(domain);
   const mode: SimplifyMode = options.audit ? "audit" : "refactor";
 
-  // Build prompt with standards
   const prompt = buildSimplifyPrompt(files, scope, mode);
 
-  // Write context file
   const contextPath = writeSimplifyContext(`task-${task.number}`, prompt);
 
-  // Output
   const modeLabel = mode === "audit" ? "AUDITORIA" : "REFATORACAO";
   console.log(`\n${"=".repeat(55)}`);
   console.log(`SIMPLIFY (${modeLabel}) — Task #${task.number}`);
@@ -86,16 +79,15 @@ export function simplifyTask(
 // SIMPLIFY AUDIT FOR REVIEW (Option C)
 // ═══════════════════════════════════════════════════════════════
 
-export function simplifyAudit(specId?: string): string | null {
-  initSchema();
+export async function simplifyAudit(specId?: string): Promise<string | null> {
+  await initSchema();
 
-  const db = getDb();
-  const spec = resolveSpec(specId, ["implementing", "reviewing"]);
+  const spec = await resolveSpec(specId, ["implementing", "reviewing"]);
 
-  // Get all feature artifacts
-  const artifacts = db
-    .query("SELECT DISTINCT path, action FROM artifacts WHERE spec_id = ?")
-    .all(spec.id) as any[];
+  const artifacts = await dbAll<any>(
+    "SELECT DISTINCT path, action FROM artifacts WHERE spec_id = ?",
+    [spec.id]
+  );
 
   if (artifacts.length === 0) {
     return null;
@@ -106,10 +98,8 @@ export function simplifyAudit(specId?: string): string | null {
     action: a.action === "created" ? "created" as const : "modified" as const,
   }));
 
-  // Use "all" scope for review (covers all domains)
   const prompt = buildSimplifyPrompt(files, "all", "audit");
 
-  // Write context file
   const contextPath = writeSimplifyContext(`audit-${spec.id}`, prompt);
 
   return contextPath;
@@ -119,22 +109,21 @@ export function simplifyAudit(specId?: string): string | null {
 // AUTO-SIMPLIFY CHECK
 // ═══════════════════════════════════════════════════════════════
 
-export function isAutoSimplifyEnabled(): boolean {
+export async function isAutoSimplifyEnabled(): Promise<boolean> {
   try {
-    const db = getDb();
-    const project = db
-      .query("SELECT auto_simplify FROM project WHERE id = 'default'")
-      .get() as any;
+    const project = await dbGet<any>(
+      "SELECT auto_simplify FROM project WHERE id = 'default'",
+      []
+    );
     return project?.auto_simplify === 1;
   } catch {
     return false;
   }
 }
 
-export function setAutoSimplify(enabled: boolean): void {
-  initSchema();
-  const db = getDb();
-  db.run(
+export async function setAutoSimplify(enabled: boolean): Promise<void> {
+  await initSchema();
+  await dbRun(
     "UPDATE project SET auto_simplify = ?, updated_at = ? WHERE id = 'default'",
     [enabled ? 1 : 0, new Date().toISOString()]
   );

package/commands/spec-resolver.test.ts

@@ -1,106 +1,110 @@
-import { describe, it, expect, beforeEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { resolveSpec, getAllActiveSpecs } from "./spec-resolver";
-import { getDb } from "../db/connection";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { cleanDb } from "../db/test-helpers";
 
-beforeEach(() => {
-  initSchema();
-  cleanDb();
+beforeEach(async () => {
+  const client = createClient({ url: ":memory:" });
+  setClient(client);
+  await initSchema();
+  await cleanDb();
 });
 
-function createSpec(id: string, name: string, phase: string, createdAt?: string) {
-  const db = getDb();
+afterEach(() => {
+  resetClient();
+});
+
+async function createSpec(id: string, name: string, phase: string, createdAt?: string) {
   const now = createdAt || new Date().toISOString();
-  db.run(
+  await dbRun(
     "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
     [id, name, phase, now, now]
   );
 }
 
 describe("resolveSpec", () => {
-  it("returns spec by ID when specId provided", () => {
-    createSpec("spec-a", "Feature A", "planning");
-    createSpec("spec-b", "Feature B", "implementing");
+  it("returns spec by ID when specId provided", async () => {
+    await createSpec("spec-a", "Feature A", "planning");
+    await createSpec("spec-b", "Feature B", "implementing");
 
-    const result = resolveSpec("spec-a");
+    const result = await resolveSpec("spec-a");
     expect(result.id).toBe("spec-a");
     expect(result.name).toBe("Feature A");
   });
 
-  it("returns most recent active spec when no specId", () => {
-    createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
-    createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
+  it("returns most recent active spec when no specId", async () => {
+    await createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
+    await createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
 
-    const result = resolveSpec();
+    const result = await resolveSpec();
     expect(result.id).toBe("spec-new");
   });
 
-  it("validates requiredPhases", () => {
-    createSpec("spec-a", "Feature A", "planning");
+  it("validates requiredPhases", async () => {
+    await createSpec("spec-a", "Feature A", "planning");
 
-    // Should work with matching phase
-    const result = resolveSpec("spec-a", ["planning"]);
+    const result = await resolveSpec("spec-a", ["planning"]);
     expect(result.phase).toBe("planning");
   });
 
-  it("accepts multiple requiredPhases", () => {
-    createSpec("spec-a", "Feature A", "checking");
-    const result = resolveSpec("spec-a", ["planning", "checking"]);
+  it("accepts multiple requiredPhases", async () => {
+    await createSpec("spec-a", "Feature A", "checking");
+    const result = await resolveSpec("spec-a", ["planning", "checking"]);
     expect(result.phase).toBe("checking");
   });
 
-  it("skips completed specs when no specId", () => {
-    createSpec("spec-done", "Done Feature", "completed", "2026-02-01T00:00:00Z");
-    createSpec("spec-active", "Active Feature", "planning", "2026-01-01T00:00:00Z");
+  it("skips completed specs when no specId", async () => {
+    await createSpec("spec-done", "Done Feature", "completed", "2026-02-01T00:00:00Z");
+    await createSpec("spec-active", "Active Feature", "planning", "2026-01-01T00:00:00Z");
 
-    const result = resolveSpec();
+    const result = await resolveSpec();
     expect(result.id).toBe("spec-active");
   });
 
-  it("skips cancelled specs when no specId", () => {
-    createSpec("spec-cancelled", "Cancelled Feature", "cancelled", "2026-02-01T00:00:00Z");
-    createSpec("spec-active", "Active Feature", "implementing", "2026-01-01T00:00:00Z");
+  it("skips cancelled specs when no specId", async () => {
+    await createSpec("spec-cancelled", "Cancelled Feature", "cancelled", "2026-02-01T00:00:00Z");
+    await createSpec("spec-active", "Active Feature", "implementing", "2026-01-01T00:00:00Z");
 
-    const result = resolveSpec();
+    const result = await resolveSpec();
     expect(result.id).toBe("spec-active");
   });
 });
 
 describe("getAllActiveSpecs", () => {
-  it("returns empty array when no active specs", () => {
-    const result = getAllActiveSpecs();
+  it("returns empty array when no active specs", async () => {
+    const result = await getAllActiveSpecs();
     expect(result).toEqual([]);
   });
 
-  it("returns all active specs ordered by created_at DESC", () => {
-    createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
-    createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
+  it("returns all active specs ordered by created_at DESC", async () => {
+    await createSpec("spec-old", "Old Feature", "planning", "2026-01-01T00:00:00Z");
+    await createSpec("spec-new", "New Feature", "implementing", "2026-02-01T00:00:00Z");
 
-    const result = getAllActiveSpecs();
+    const result = await getAllActiveSpecs();
     expect(result.length).toBe(2);
     expect(result[0].id).toBe("spec-new");
     expect(result[1].id).toBe("spec-old");
   });
 
-  it("excludes completed and cancelled specs", () => {
-    createSpec("spec-active", "Active", "planning");
-    createSpec("spec-done", "Done", "completed");
-    createSpec("spec-cancelled", "Cancelled", "cancelled");
+  it("excludes completed and cancelled specs", async () => {
+    await createSpec("spec-active", "Active", "planning");
+    await createSpec("spec-done", "Done", "completed");
+    await createSpec("spec-cancelled", "Cancelled", "cancelled");
 
-    const result = getAllActiveSpecs();
+    const result = await getAllActiveSpecs();
     expect(result.length).toBe(1);
     expect(result[0].id).toBe("spec-active");
   });
 
-  it("returns multiple specs in different phases", () => {
-    createSpec("spec-plan", "Planning Feature", "planning", "2026-01-01T00:00:00Z");
-    createSpec("spec-impl", "Implementing Feature", "implementing", "2026-01-02T00:00:00Z");
-    createSpec("spec-rev", "Reviewing Feature", "reviewing", "2026-01-03T00:00:00Z");
+  it("returns multiple specs in different phases", async () => {
+    await createSpec("spec-plan", "Planning Feature", "planning", "2026-01-01T00:00:00Z");
+    await createSpec("spec-impl", "Implementing Feature", "implementing", "2026-01-02T00:00:00Z");
+    await createSpec("spec-rev", "Reviewing Feature", "reviewing", "2026-01-03T00:00:00Z");
 
-    const result = getAllActiveSpecs();
+    const result = await getAllActiveSpecs();
     expect(result.length).toBe(3);
-    // Ordered by created_at DESC
     expect(result[0].id).toBe("spec-rev");
     expect(result[1].id).toBe("spec-impl");
     expect(result[2].id).toBe("spec-plan");