@codexa/cli 9.0.31 → 9.0.33

package/commands/task.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema, getPatternsForFiles, getPatternsByScope, getRecentReasoning, claimTask, recordAgentPerformance, detectStuckTasks } from "../db/schema";
 import { enforceGate } from "../gates/validator";
 import { parseSubagentReturn, formatValidationErrors } from "../protocol/subagent-protocol";
@@ -16,10 +16,9 @@ import { getContextBudget, formatContextWarning, estimateTokens } from "../conte
 import { isAutoSimplifyEnabled } from "./simplify";
 import { buildSimplifyPrompt, writeSimplifyContext, type SimplifyFile } from "../simplify/prompt-builder";
 
-export function taskNext(json: boolean = false, specId?: string): void {
-  initSchema();
+export async function taskNext(json: boolean = false, specId?: string): Promise<void> {
+  await initSchema();
 
-  const db = getDb();
   const spec = resolveSpecOrNull(specId, ["implementing"]);
 
   if (!spec) {
@@ -31,14 +30,12 @@ export function taskNext(json: boolean = false, specId?: string): void {
   }
 
   // v9.9: Get current phase info
-  const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
+  const context = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [spec.id]);
   const currentPhase = context?.current_phase || 1;
   const totalPhases = context?.total_phases || 1;
 
   // Buscar tasks pendentes cujas dependencias estao todas concluidas
-  const allTasks = db
-    .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
-    .all(spec.id) as any[];
+  const allTasks = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number", [spec.id]);
 
   const available: any[] = [];
 
@@ -86,7 +83,7 @@ export function taskNext(json: boolean = false, specId?: string): void {
     } else {
       console.log("\nNenhuma task disponivel no momento.");
       console.log(`Tasks em execucao ou bloqueadas: ${pending.length}`);
-      const stuck = detectStuckTasks(spec.id);
+      const stuck = await detectStuckTasks(spec.id);
       if (stuck.length > 0) {
         showStuckWarning(stuck);
       } else {
@@ -150,11 +147,10 @@ function showStuckWarning(stuck: any[]): void {
   console.log(`  Use: task done <id> --force --force-reason "timeout" para liberar\n`);
 }
 
-export function taskStart(ids: string, json: boolean = false, minimalContext: boolean = false, specId?: string): void {
-  initSchema();
+export async function taskStart(ids: string, json: boolean = false, minimalContext: boolean = false, specId?: string): Promise<void> {
+  await initSchema();
   enforceGate("task-start");
 
-  const db = getDb();
   const now = new Date().toISOString();
 
   const spec = resolveSpec(specId, ["implementing"]);
@@ -163,7 +159,7 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
   const startedTasks: any[] = [];
 
   for (const taskId of taskIds) {
-    const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
+    const task = await dbGet<any>("SELECT * FROM tasks WHERE id = ?", [taskId]);
 
     if (!task) {
       throw new TaskStateError(`Task #${taskId} nao encontrada.`);
@@ -173,8 +169,8 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
     enforceGate("task-start", { taskId });
 
     // Claim atomico: UPDATE ... WHERE status = 'pending'
-    if (!claimTask(taskId)) {
-      const current = db.query("SELECT status FROM tasks WHERE id = ?").get(taskId) as any;
+    if (!(await claimTask(taskId))) {
+      const current = await dbGet<any>("SELECT status FROM tasks WHERE id = ?", [taskId]);
       throw new TaskStateError(
         `Task #${task.number} nao pode ser iniciada (status atual: ${current?.status || "desconhecido"}).`
       );
@@ -184,19 +180,20 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
   }
 
   // Atualizar contexto
-  db.run("UPDATE context SET current_task = ?, updated_at = ? WHERE spec_id = ?", [
+  await dbRun("UPDATE context SET current_task = ?, updated_at = ? WHERE spec_id = ?", [
     startedTasks[0].number,
     now,
     spec.id,
   ]);
 
   // v9.0: Mostrar resumo de knowledge relevante antes de iniciar
-  const allKnowledge = db.query(
+  const allKnowledge = await dbAll<any>(
     `SELECT * FROM knowledge
      WHERE spec_id = ? AND severity IN ('critical', 'warning')
      ORDER BY severity DESC, created_at DESC
-     LIMIT 10`
-  ).all(spec.id) as any[];
+     LIMIT 10`,
+    [spec.id]
+  );
 
   if (allKnowledge.length > 0 && !json) {
     console.log(`\n[i] Knowledge ativo (${allKnowledge.length}):`);
@@ -211,7 +208,8 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
   }
 
   if (json) {
-    const contexts = startedTasks.map((task) => {
+    const contexts: any[] = [];
+    for (const task of startedTasks) {
       const taskFiles = task.files ? JSON.parse(task.files) : [];
       const agentDomain = getAgentDomain(task.agent);
       const agentScope = domainToScope(agentDomain);
@@ -233,16 +231,15 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
 
       // v11.0: Inline context delivery — full context in prompt, no files
       const inlineContext = minimalContext
-        ? getMinimalContextForSubagent(task.id)
-        : getContextForSubagent(task.id);
+        ? await getMinimalContextForSubagent(task.id)
+        : await getContextForSubagent(task.id);
 
       // Build pending knowledge section
-      const pendingKnowledgeForPrompt = (() => {
-        const unread = getUnreadKnowledgeForTask(spec.id, task.id);
-        const critical = unread.filter((k: any) => k.severity === 'critical' && k.task_origin !== task.id);
-        if (critical.length === 0) return "";
-        return `## KNOWLEDGE PENDENTE (OBRIGATORIO)\n\nVoce DEVE reconhecer estes items antes de completar a task:\n${critical.map((k: any) => `- [ID ${k.id}] ${k.content}`).join("\n")}\n\nUse: \`codexa knowledge ack <id>\` para cada item.`;
-      })();
+      const unreadForPrompt = await getUnreadKnowledgeForTask(spec.id, task.id);
+      const criticalForPrompt = unreadForPrompt.filter((k: any) => k.severity === 'critical' && k.task_origin !== task.id);
+      const pendingKnowledgeForPrompt = criticalForPrompt.length === 0
+        ? ""
+        : `## KNOWLEDGE PENDENTE (OBRIGATORIO)\n\nVoce DEVE reconhecer estes items antes de completar a task:\n${criticalForPrompt.map((k: any) => `- [ID ${k.id}] ${k.content}`).join("\n")}\n\nUse: \`codexa knowledge ack <id>\` para cada item.`;
 
       // Pre-built prompt for subagent (orchestrator just passes it)
       const subagentPrompt = loadTemplate("subagent-prompt-lean", {
@@ -258,9 +255,11 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
       });
 
       // Context budget estimation
-      const completedTaskCount = (db.query(
-        "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'"
-      ).get(spec.id) as any)?.c || 0;
+      const completedTaskRow = await dbGet<any>(
+        "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'",
+        [spec.id]
+      );
+      const completedTaskCount = completedTaskRow?.c || 0;
 
       const agentProfile = getProfileForDomain(agentDomain);
       const contextBudget = getContextBudget(subagentPrompt, completedTaskCount, agentProfile);
@@ -286,7 +285,7 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
       };
 
       // Unread knowledge for orchestrator awareness
-      const unreadKnowledge = getUnreadKnowledgeForTask(spec.id, task.id);
+      const unreadKnowledge = await getUnreadKnowledgeForTask(spec.id, task.id);
       if (unreadKnowledge.length > 0) {
         output.unreadKnowledge = unreadKnowledge.map((k: any) => ({
           id: k.id, category: k.category, content: k.content,
@@ -294,8 +293,8 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
         }));
       }
 
-      return output;
-    });
+      contexts.push(output);
+    }
     console.log(JSON.stringify({ started: contexts }));
     return;
   }
@@ -307,18 +306,17 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
   console.log(`\nAo concluir, use: task done <id> --checkpoint "resumo"\n`);
 }
 
-export function taskDone(id: string, options: { checkpoint: string; files?: string; force?: boolean; forceReason?: string; output?: string; simplify?: boolean }): void {
-  initSchema();
+export async function taskDone(id: string, options: { checkpoint: string; files?: string; force?: boolean; forceReason?: string; output?: string; simplify?: boolean }): Promise<void> {
+  await initSchema();
 
   const taskId = parseInt(id);
-  const db = getDb();
-  const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
+  const task = await dbGet<any>("SELECT * FROM tasks WHERE id = ?", [taskId]);
 
   if (!task) {
     throw new TaskStateError(`Task #${taskId} nao encontrada.`);
   }
 
-  const spec = db.query("SELECT * FROM specs WHERE id = ?").get(task.spec_id) as any;
+  const spec = await dbGet<any>("SELECT * FROM specs WHERE id = ?", [task.spec_id]);
   const now = new Date().toISOString();
 
   // ============================================================
@@ -397,7 +395,8 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     console.log(formatProcessResult(processResult));
 
     // v8.3: BLOCKING check para knowledge critico nao reconhecido (substitui warning v8.2)
-    const unackedCritical = getUnreadKnowledgeForTask(spec.id, taskId)
+    const allUnackedKnowledge = await getUnreadKnowledgeForTask(spec.id, taskId);
+    const unackedCritical = allUnackedKnowledge
         .filter((k: any) => k.severity === 'critical' && k.task_origin !== taskId);
     if (unackedCritical.length > 0) {
       if (!options.force) {
@@ -479,7 +478,7 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
   }
 
   // Marcar como done
-  db.run(
+  await dbRun(
     "UPDATE tasks SET status = 'done', checkpoint = ?, completed_at = ? WHERE id = ?",
     [checkpoint, now, taskId]
   );
@@ -489,12 +488,14 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     const agentType = task.agent || "general-purpose";
     const startedAt = task.started_at ? new Date(task.started_at).getTime() : Date.now();
     const duration = Date.now() - startedAt;
-    const bypassCount = (db.query(
-      "SELECT COUNT(*) as c FROM gate_bypasses WHERE task_id = ?"
-    ).get(taskId) as any)?.c || 0;
+    const bypassRow = await dbGet<any>(
+      "SELECT COUNT(*) as c FROM gate_bypasses WHERE task_id = ?",
+      [taskId]
+    );
+    const bypassCount = bypassRow?.c || 0;
     const totalGates = 8;
 
-    recordAgentPerformance({
+    await recordAgentPerformance({
       agentType,
       specId: spec.id,
       taskId,
@@ -503,7 +504,7 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
       bypassesUsed: bypassCount,
       filesCreated: subagentData?.files_created?.length || 0,
       filesModified: subagentData?.files_modified?.length || 0,
-      contextSizeBytes: estimateTokens(getContextForSubagent(task.id)) * 4,
+      contextSizeBytes: estimateTokens(await getContextForSubagent(task.id)) * 4,
       executionDurationMs: duration,
     });
   } catch { /* nao-critico: nao falhar task done por tracking de performance */ }
@@ -512,7 +513,7 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
   if (!subagentData && options.files) {
     const files = options.files.split(",").map((s) => s.trim());
     for (const file of files) {
-      db.run(
+      await dbRun(
         `INSERT OR REPLACE INTO artifacts (spec_id, task_ref, path, action, created_at)
          VALUES (?, ?, ?, 'created', ?)`,
         [spec.id, task.number, file, now]
@@ -521,52 +522,58 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
   }
 
   // Atualizar contexto
-  const doneCount = db
-    .query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'")
-    .get(spec.id) as any;
-  const totalCount = db
-    .query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?")
-    .get(spec.id) as any;
-
-  db.run(
+  const doneCount = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'",
+    [spec.id]
+  );
+  const totalCount = await dbGet<any>(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?",
+    [spec.id]
+  );
+
+  await dbRun(
     "UPDATE context SET last_checkpoint = ?, updated_at = ? WHERE spec_id = ?",
     [checkpoint, now, spec.id]
   );
 
   // v9.9: Phase-aware progress
-  const ctx = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
+  const ctx = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [spec.id]);
   const currentPhase = ctx?.current_phase || 1;
   const totalPhases = ctx?.total_phases || 1;
 
   console.log(`\nTask #${task.number} concluida!`);
   console.log(`Checkpoint: ${options.checkpoint}`);
-  console.log(`Progresso: ${doneCount.c}/${totalCount.c} tasks`);
+  console.log(`Progresso: ${doneCount?.c || 0}/${totalCount?.c || 0} tasks`);
 
   if (totalPhases > 1) {
-    const phaseTasks = db
-      .query("SELECT * FROM tasks WHERE spec_id = ? AND phase = ?")
-      .all(spec.id, currentPhase) as any[];
+    const phaseTasks = await dbAll<any>(
+      "SELECT * FROM tasks WHERE spec_id = ? AND phase = ?",
+      [spec.id, currentPhase]
+    );
     const phaseDone = phaseTasks.filter((t: any) => t.status === "done").length;
     console.log(`Fase ${currentPhase}/${totalPhases}: ${phaseDone}/${phaseTasks.length} tasks`);
 
     if (phaseDone === phaseTasks.length && currentPhase < totalPhases) {
       // Phase complete — show phase summary
-      const phaseDecisions = db
-        .query("SELECT COUNT(*) as c FROM decisions WHERE spec_id = ?")
-        .get(spec.id) as any;
-      const phaseKnowledge = db
-        .query("SELECT COUNT(*) as c FROM knowledge WHERE spec_id = ? AND severity != 'archived'")
-        .get(spec.id) as any;
+      const phaseDecisions = await dbGet<any>(
+        "SELECT COUNT(*) as c FROM decisions WHERE spec_id = ?",
+        [spec.id]
+      );
+      const phaseKnowledge = await dbGet<any>(
+        "SELECT COUNT(*) as c FROM knowledge WHERE spec_id = ? AND severity != 'archived'",
+        [spec.id]
+      );
 
-      const nextPhaseTasks = db
-        .query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND phase = ?")
-        .get(spec.id, currentPhase + 1) as any;
+      const nextPhaseTasks = await dbGet<any>(
+        "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND phase = ?",
+        [spec.id, currentPhase + 1]
+      );
 
       console.log(`\n${"=".repeat(55)}`);
       console.log(`FASE ${currentPhase} CONCLUIDA (${phaseDone}/${phaseTasks.length} tasks)`);
       console.log(`${"=".repeat(55)}`);
-      console.log(`  Decisions acumuladas: ${phaseDecisions.c}`);
-      console.log(`  Knowledge acumulado: ${phaseKnowledge.c}`);
+      console.log(`  Decisions acumuladas: ${phaseDecisions?.c || 0}`);
+      console.log(`  Knowledge acumulado: ${phaseKnowledge?.c || 0}`);
       console.log(`\n  Proxima fase: ${currentPhase + 1}/${totalPhases} (${nextPhaseTasks?.c || 0} tasks)`);
       console.log(`\n  Recomendacao: Compactar contexto antes de continuar`);
       console.log(`  -> codexa task phase-advance [--no-compact] [--spec ${spec.id}]`);
@@ -575,12 +582,12 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     }
   }
 
-  if (doneCount.c === totalCount.c) {
+  if (doneCount?.c === totalCount?.c) {
     // Mostrar resumo completo da implementacao
-    const allTasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
-    const allDecisions = db.query("SELECT * FROM decisions WHERE spec_id = ?").all(spec.id) as any[];
-    const allArtifacts = db.query("SELECT * FROM artifacts WHERE spec_id = ?").all(spec.id) as any[];
-    showImplementationSummary(spec.id, allTasks, allArtifacts, allDecisions);
+    const allTasks = await dbAll<any>("SELECT * FROM tasks WHERE spec_id = ?", [spec.id]);
+    const allDecisions = await dbAll<any>("SELECT * FROM decisions WHERE spec_id = ?", [spec.id]);
+    const allArtifacts = await dbAll<any>("SELECT * FROM artifacts WHERE spec_id = ?", [spec.id]);
+    await showImplementationSummary(spec.id, allTasks, allArtifacts, allDecisions);
   } else {
     console.log(`\nProximas tasks: task next\n`);
   }
@@ -590,15 +597,14 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
  * Mostra resumo detalhado da implementacao apos todas as tasks concluidas
  * Permite ao usuario decidir se quer fazer review ou nao
  */
-function showImplementationSummary(
+async function showImplementationSummary(
   specId: number,
   tasks: any[],
   artifacts: any[],
   decisions: any[]
-): void {
-  const db = getDb();
-  const spec = db.query("SELECT * FROM specs WHERE id = ?").get(specId) as any;
-  const knowledge = db.query("SELECT * FROM knowledge WHERE spec_id = ?").all(specId) as any[];
+): Promise<void> {
+  const spec = await dbGet<any>("SELECT * FROM specs WHERE id = ?", [specId]);
+  const knowledge = await dbAll<any>("SELECT * FROM knowledge WHERE spec_id = ?", [specId]);
 
   console.log(`\n${"=".repeat(60)}`);
   console.log(`IMPLEMENTACAO CONCLUIDA: ${spec.name}`);
@@ -694,12 +700,11 @@ function showImplementationSummary(
 }
 
 // v9.9: Phase advance — compact context and move to next phase
-export function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean; spec?: string } = {}): void {
-  initSchema();
-  const db = getDb();
+export async function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean; spec?: string } = {}): Promise<void> {
+  await initSchema();
 
   const spec = resolveSpec(options.spec, ["implementing"]);
-  const ctx = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
+  const ctx = await dbGet<any>("SELECT * FROM context WHERE spec_id = ?", [spec.id]);
   const currentPhase = ctx?.current_phase || 1;
   const totalPhases = ctx?.total_phases || 1;
 
@@ -715,9 +720,10 @@ export function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean;
   }
 
   // Verify current phase is fully complete
-  const phaseTasks = db
-    .query("SELECT * FROM tasks WHERE spec_id = ? AND phase = ?")
-    .all(spec.id, currentPhase) as any[];
+  const phaseTasks = await dbAll<any>(
+    "SELECT * FROM tasks WHERE spec_id = ? AND phase = ?",
+    [spec.id, currentPhase]
+  );
   const pendingInPhase = phaseTasks.filter((t: any) => t.status !== "done" && t.status !== "cancelled");
 
   if (pendingInPhase.length > 0) {
@@ -732,8 +738,8 @@ export function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean;
   // Compact knowledge, reasoning, and clean up stale files (unless --no-compact)
   if (!options.noCompact) {
     console.log(`\nCompactando contexto da fase ${currentPhase}...`);
-    compactKnowledge({ specId: spec.id });
-    const reasoningResult = compactReasoning({ specId: spec.id });
+    await compactKnowledge({ specId: spec.id });
+    const reasoningResult = await compactReasoning({ specId: spec.id });
     if (reasoningResult.archived > 0) {
       console.log(`  Reasoning compactado: ${reasoningResult.archived} entradas removidas, ${reasoningResult.kept} mantidas`);
     }
@@ -741,12 +747,14 @@ export function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean;
 
   // Create phase summary as critical knowledge
   const phaseTaskNames = phaseTasks.map((t: any) => t.name).join(", ");
-  const decisionCount = (db.query("SELECT COUNT(*) as c FROM decisions WHERE spec_id = ?").get(spec.id) as any).c;
-  const artifactCount = (db.query("SELECT COUNT(*) as c FROM artifacts WHERE spec_id = ?").get(spec.id) as any).c;
+  const decisionCountRow = await dbGet<any>("SELECT COUNT(*) as c FROM decisions WHERE spec_id = ?", [spec.id]);
+  const artifactCountRow = await dbGet<any>("SELECT COUNT(*) as c FROM artifacts WHERE spec_id = ?", [spec.id]);
+  const decisionCount = decisionCountRow?.c || 0;
+  const artifactCount = artifactCountRow?.c || 0;
 
   const summaryContent = `Resumo Fase ${currentPhase}: ${phaseTasks.length} tasks concluidas (${phaseTaskNames.substring(0, 200)}). ${decisionCount} decisions, ${artifactCount} artefatos acumulados.`;
 
-  db.run(
+  await dbRun(
     `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
      VALUES (?, 0, 'phase_summary', ?, 'critical', 'all', ?)`,
     [spec.id, summaryContent, now]
@@ -754,15 +762,16 @@ export function taskPhaseAdvance(options: { noCompact?: boolean; json?: boolean;
 
   // Advance to next phase
   const nextPhase = currentPhase + 1;
-  db.run(
+  await dbRun(
     "UPDATE context SET current_phase = ?, updated_at = ? WHERE spec_id = ?",
     [nextPhase, now, spec.id]
   );
 
   // Show next phase info
-  const nextPhaseTasks = db
-    .query("SELECT * FROM tasks WHERE spec_id = ? AND phase = ? ORDER BY number")
-    .all(spec.id, nextPhase) as any[];
+  const nextPhaseTasks = await dbAll<any>(
+    "SELECT * FROM tasks WHERE spec_id = ? AND phase = ? ORDER BY number",
+    [spec.id, nextPhase]
+  );
 
   if (options.json) {
     console.log(JSON.stringify({

package/commands/team.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { Database } from "bun:sqlite";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbRun } from "../db/connection";
+import { initSchema } from "../db/schema";
 import {
   detectPhase,
   buildLeadSpawnInstruction,
@@ -10,103 +12,40 @@ import {
   type TeammateConfig,
 } from "./team";
 
-// ─────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────
-
-function createTestDb(): Database {
-  const db = new Database(":memory:");
-
-  db.run(`CREATE TABLE specs (
-    id TEXT PRIMARY KEY, name TEXT, phase TEXT, approved_at TEXT,
-    analysis_id TEXT, created_at TEXT, updated_at TEXT
-  )`);
-
-  db.run(`CREATE TABLE tasks (
-    id INTEGER PRIMARY KEY AUTOINCREMENT, spec_id TEXT, number INTEGER,
-    name TEXT, depends_on TEXT, can_parallel INTEGER DEFAULT 1,
-    agent TEXT, files TEXT, status TEXT DEFAULT 'pending',
-    checkpoint TEXT, started_at TEXT, completed_at TEXT
-  )`);
-
-  db.run(`CREATE TABLE artifacts (
-    id INTEGER PRIMARY KEY AUTOINCREMENT, spec_id TEXT,
-    task_ref INTEGER, path TEXT, action TEXT, created_at TEXT
-  )`);
-
-  db.run(`CREATE TABLE architectural_analyses (
-    id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, status TEXT DEFAULT 'pending'
-  )`);
-
-  db.run(`CREATE TABLE project (
-    id TEXT PRIMARY KEY DEFAULT 'default', stack TEXT,
-    cli_version TEXT, typecheck_command TEXT, grepai_workspace TEXT
-  )`);
-
-  db.run("INSERT INTO project (id) VALUES ('default')");
-
-  return db;
-}
-
-function insertSpec(db: Database, id: string, name: string, phase: string): void {
-  db.run("INSERT INTO specs (id, name, phase, created_at) VALUES (?, ?, ?, datetime('now'))", [id, name, phase]);
-}
-
-function insertTask(
-  db: Database,
-  specId: string,
-  number: number,
-  name: string,
-  options: { agent?: string; canParallel?: boolean; dependsOn?: number[]; status?: string } = {}
-): number {
-  const result = db.run(
-    `INSERT INTO tasks (spec_id, number, name, agent, can_parallel, depends_on, status)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
-    [
-      specId,
-      number,
-      name,
-      options.agent || "general",
-      options.canParallel !== false ? 1 : 0,
-      options.dependsOn ? JSON.stringify(options.dependsOn) : null,
-      options.status || "pending",
-    ]
-  );
-  return Number(result.lastInsertRowid);
-}
-
-function insertArtifact(db: Database, specId: string, taskRef: number, path: string): void {
-  db.run("INSERT INTO artifacts (spec_id, task_ref, path, action) VALUES (?, ?, ?, 'created')", [specId, taskRef, path]);
-}
-
 // ─────────────────────────────────────────────────────────────────
 // Tests
 // ─────────────────────────────────────────────────────────────────
 
 describe("detectPhase", () => {
-  it("detecta imp quando spec.phase = implementing", () => {
-    const db = createTestDb();
+  beforeEach(async () => {
+    const client = createClient({ url: ":memory:" });
+    setClient(client);
+    await initSchema();
+  });
+
+  afterEach(() => {
+    resetClient();
+  });
+
+  it("detecta imp quando spec.phase = implementing", async () => {
     const spec = { phase: "implementing" };
-    expect(detectPhase(db, spec)).toBe("imp");
+    expect(await detectPhase(spec)).toBe("imp");
   });
 
-  it("detecta rev quando spec.phase = reviewing", () => {
-    const db = createTestDb();
+  it("detecta rev quando spec.phase = reviewing", async () => {
     const spec = { phase: "reviewing" };
-    expect(detectPhase(db, spec)).toBe("rev");
+    expect(await detectPhase(spec)).toBe("rev");
   });
 
-  it("detecta architect quando ha analise pendente", () => {
-    const db = createTestDb();
-    db.run("INSERT INTO architectural_analyses (name, status) VALUES ('test', 'pending')");
+  it("detecta architect quando ha analise pendente", async () => {
+    await dbRun("INSERT INTO architectural_analyses (id, name, description, status) VALUES ('test-id', 'test', 'test description', 'pending')");
     const spec = { phase: "planning" };
-    expect(detectPhase(db, spec)).toBe("architect");
+    expect(await detectPhase(spec)).toBe("architect");
   });
 
-  it("retorna phase original se nao ha analise pendente", () => {
-    const db = createTestDb();
+  it("retorna phase original se nao ha analise pendente", async () => {
     const spec = { phase: "planning" };
-    expect(detectPhase(db, spec)).toBe("planning");
+    expect(await detectPhase(spec)).toBe("planning");
   });
 });