@codexa/cli 9.0.31 → 9.0.33

package/db/schema.ts

@@ -1,11 +1,9 @@
-import { Database } from "bun:sqlite";
-import { getDb } from "./connection";
+import type { Client, Transaction } from "@libsql/client";
+import { getDb, setClient, dbGet, dbAll, dbRun, dbExec, ensureDatabase } from "./connection";
 
-export function initSchema(): void {
-  const db = getDb();
-
-  db.exec(`
-    -- 1. Feature sendo desenvolvida
+export async function initSchema(): Promise<void> {
+  await ensureDatabase();
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS specs (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
@@ -13,9 +11,9 @@ export function initSchema(): void {
       approved_at TEXT,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT
-    );
-
-    -- 2. Contexto compartilhado (o coracao do sistema)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS context (
       spec_id TEXT PRIMARY KEY REFERENCES specs(id),
       objective TEXT NOT NULL,
@@ -26,9 +24,9 @@ export function initSchema(): void {
       total_tasks INTEGER,
       last_checkpoint TEXT,
       updated_at TEXT
-    );
-
-    -- 3. Tarefas com dependencias (para paralelizacao)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS tasks (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -42,9 +40,9 @@ export function initSchema(): void {
       checkpoint TEXT,
       completed_at TEXT,
       UNIQUE(spec_id, number)
-    );
-
-    -- 4. Decisoes (registro critico)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS decisions (
       id TEXT PRIMARY KEY,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -54,9 +52,9 @@ export function initSchema(): void {
       rationale TEXT,
       status TEXT DEFAULT 'active',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 5. Artefatos
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS artifacts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -65,9 +63,9 @@ export function initSchema(): void {
       action TEXT NOT NULL,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       UNIQUE(spec_id, path)
-    );
-
-    -- 6. Review (fase REV)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS review (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -75,27 +73,27 @@ export function initSchema(): void {
       deviations TEXT,
       status TEXT DEFAULT 'pending',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 7. Snapshots (recovery)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS snapshots (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
       data TEXT NOT NULL,
       trigger TEXT NOT NULL,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 8. Projeto (informacoes detectadas no discover)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS project (
       id TEXT PRIMARY KEY DEFAULT 'default',
       name TEXT,
       stack TEXT NOT NULL,
       discovered_at TEXT,
       updated_at TEXT
-    );
-
-    -- 9. Standards do projeto
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS standards (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       category TEXT NOT NULL,
@@ -106,9 +104,9 @@ export function initSchema(): void {
       enforcement TEXT DEFAULT 'required',
       source TEXT,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 10. Knowledge broadcast (compartilhamento em tempo real)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS knowledge (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -118,9 +116,9 @@ export function initSchema(): void {
       severity TEXT DEFAULT 'info',
       broadcast_to TEXT DEFAULT 'all',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 11. Gate bypass log (auditoria de bypasses)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS gate_bypasses (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT NOT NULL REFERENCES specs(id),
@@ -128,9 +126,9 @@ export function initSchema(): void {
       gate_name TEXT NOT NULL,
       reason TEXT,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 12. Product context (PRD/contexto de produto)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS product_context (
       id TEXT PRIMARY KEY DEFAULT 'default',
       name TEXT NOT NULL,
@@ -144,9 +142,9 @@ export function initSchema(): void {
       source TEXT DEFAULT 'guide',
       discovered_at TEXT,
       updated_at TEXT
-    );
-
-    -- 13. Product goals (objetivos do produto)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS product_goals (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       product_id TEXT NOT NULL DEFAULT 'default' REFERENCES product_context(id),
@@ -155,9 +153,9 @@ export function initSchema(): void {
       priority TEXT DEFAULT 'medium',
       status TEXT DEFAULT 'active',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 14. Product features (features core do produto)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS product_features (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       product_id TEXT NOT NULL DEFAULT 'default' REFERENCES product_context(id),
@@ -166,9 +164,9 @@ export function initSchema(): void {
       priority TEXT DEFAULT 'medium',
       status TEXT DEFAULT 'planned',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 15. Library contexts (contexto atualizado por biblioteca)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS lib_contexts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       lib_name TEXT NOT NULL UNIQUE,
@@ -177,117 +175,83 @@ export function initSchema(): void {
       source_url TEXT,
       researched_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT
-    );
-
-    -- 16. Agent lib mappings (quais libs cada agente carrega)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS agent_lib_mappings (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       agent_type TEXT NOT NULL,
       lib_name TEXT NOT NULL,
       priority INTEGER DEFAULT 0,
       UNIQUE(agent_type, lib_name)
-    );
-
-    -- 17. Implementation patterns (padroes extraidos do codigo - v7.4)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS implementation_patterns (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-
-      -- Identificacao
-      category TEXT NOT NULL,        -- component, hook, service, route, schema, test, action
-      name TEXT NOT NULL UNIQUE,     -- ex: "page-component", "data-hook", "api-route"
-
-      -- Contexto
-      scope TEXT NOT NULL,           -- frontend, backend, database, testing
-      applies_to TEXT NOT NULL,      -- glob pattern: "app/**/page.tsx", "src/hooks/*.ts"
-
-      -- O Padrao Extraido
-      structure TEXT NOT NULL,       -- JSON com estrutura comum (imports, exports, patterns, conventions)
-      template TEXT NOT NULL,        -- Template de codigo com placeholders
-      examples TEXT NOT NULL,        -- JSON array de arquivos que seguem este padrao
-
-      -- Anti-patterns identificados
-      anti_patterns TEXT,            -- JSON array de anti-patterns encontrados
-
-      -- Metadados
-      confidence REAL DEFAULT 0.8,   -- 0-1, baseado em quantos arquivos seguem
-      extracted_from INTEGER,        -- Quantos arquivos foram analisados
-
-      -- Auditoria
+      category TEXT NOT NULL,
+      name TEXT NOT NULL UNIQUE,
+      scope TEXT NOT NULL,
+      applies_to TEXT NOT NULL,
+      structure TEXT NOT NULL,
+      template TEXT NOT NULL,
+      examples TEXT NOT NULL,
+      anti_patterns TEXT,
+      confidence REAL DEFAULT 0.8,
+      extracted_from INTEGER,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT
-    );
-
-    -- 18. Knowledge Graph (v8.0 - Relacoes entre entidades)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS knowledge_graph (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT REFERENCES specs(id),
-
-      -- No de origem
-      source_type TEXT NOT NULL,  -- file, decision, pattern, task, artifact
+      source_type TEXT NOT NULL,
       source_id TEXT NOT NULL,
-
-      -- No de destino
       target_type TEXT NOT NULL,
       target_id TEXT NOT NULL,
-
-      -- Relacao
-      relation TEXT NOT NULL,     -- uses, implements, depends_on, modifies, contradicts, extracted_from
-
-      -- Metadados
-      metadata TEXT,              -- JSON com informacoes adicionais
-
+      relation TEXT NOT NULL,
+      metadata TEXT,
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 19. Reasoning Log (v8.0 - Historico de raciocinio)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS reasoning_log (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       spec_id TEXT REFERENCES specs(id),
       task_id INTEGER REFERENCES tasks(id),
-
-      -- O raciocinio
-      category TEXT NOT NULL,     -- decision, discovery, error, success, challenge, recommendation
-      thought TEXT NOT NULL,      -- "Escolhi X porque Y"
-
-      -- Contexto
-      related_files TEXT,         -- JSON array de arquivos
-      related_decisions TEXT,     -- JSON array de decision IDs
-      related_patterns TEXT,      -- JSON array de pattern names
-
-      -- Importancia
-      importance TEXT DEFAULT 'normal',  -- critical, high, normal, low
-
+      category TEXT NOT NULL,
+      thought TEXT NOT NULL,
+      related_files TEXT,
+      related_decisions TEXT,
+      related_patterns TEXT,
+      importance TEXT DEFAULT 'normal',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 20. Architectural Analyses (v8.1 - migrado de architect.ts para schema central)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS architectural_analyses (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
       description TEXT NOT NULL,
       status TEXT NOT NULL DEFAULT 'pending',
-
-      -- Conteudo JSON
       context TEXT,
       current_architecture TEXT,
       approach TEXT,
       chosen_alternative TEXT,
-      diagrams TEXT,           -- JSON array
-      baby_steps TEXT,         -- JSON array
-      risks TEXT,              -- JSON array
-      alternatives TEXT,       -- JSON array
-      decisions TEXT,          -- JSON array
-
-      -- Arquivo gerado
+      diagrams TEXT,
+      baby_steps TEXT,
+      risks TEXT,
+      alternatives TEXT,
+      decisions TEXT,
       file_path TEXT,
-
-      -- Timestamps
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT,
       approved_at TEXT
-    );
-
-    -- 22. Project Utilities (v8.5 - DRY enforcement utility map)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS project_utilities (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       file_path TEXT NOT NULL,
@@ -301,61 +265,60 @@ export function initSchema(): void {
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT,
       UNIQUE(file_path, utility_name)
-    );
-
-    -- 23. Schema Migrations tracking (v9.2)
+    )
+  `);
+  await dbExec(`
     CREATE TABLE IF NOT EXISTS schema_migrations (
       version TEXT PRIMARY KEY,
       description TEXT NOT NULL,
       applied_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- Indices para performance
-    CREATE INDEX IF NOT EXISTS idx_tasks_spec ON tasks(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
-    CREATE INDEX IF NOT EXISTS idx_decisions_spec ON decisions(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_artifacts_spec ON artifacts(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_snapshots_spec ON snapshots(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_standards_category ON standards(category);
-    CREATE INDEX IF NOT EXISTS idx_standards_scope ON standards(scope);
-    CREATE INDEX IF NOT EXISTS idx_knowledge_spec ON knowledge(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_knowledge_category ON knowledge(category);
-    CREATE INDEX IF NOT EXISTS idx_knowledge_severity ON knowledge(severity);
-    CREATE INDEX IF NOT EXISTS idx_gate_bypasses_spec ON gate_bypasses(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_product_goals_product ON product_goals(product_id);
-    CREATE INDEX IF NOT EXISTS idx_product_goals_category ON product_goals(category);
-    CREATE INDEX IF NOT EXISTS idx_product_features_product ON product_features(product_id);
-    CREATE INDEX IF NOT EXISTS idx_product_features_priority ON product_features(priority);
-    CREATE INDEX IF NOT EXISTS idx_lib_contexts_lib ON lib_contexts(lib_name);
-    CREATE INDEX IF NOT EXISTS idx_agent_lib_mappings_agent ON agent_lib_mappings(agent_type);
-    CREATE INDEX IF NOT EXISTS idx_impl_patterns_category ON implementation_patterns(category);
-    CREATE INDEX IF NOT EXISTS idx_impl_patterns_scope ON implementation_patterns(scope);
-    CREATE INDEX IF NOT EXISTS idx_impl_patterns_name ON implementation_patterns(name);
-
-    -- v8.0: Indices para Knowledge Graph
-    CREATE INDEX IF NOT EXISTS idx_kg_source ON knowledge_graph(source_type, source_id);
-    CREATE INDEX IF NOT EXISTS idx_kg_target ON knowledge_graph(target_type, target_id);
-    CREATE INDEX IF NOT EXISTS idx_kg_relation ON knowledge_graph(relation);
-    CREATE INDEX IF NOT EXISTS idx_kg_spec ON knowledge_graph(spec_id);
-
-    -- v8.0: Indices para Reasoning Log
-    CREATE INDEX IF NOT EXISTS idx_reasoning_spec ON reasoning_log(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_reasoning_task ON reasoning_log(task_id);
-    CREATE INDEX IF NOT EXISTS idx_reasoning_category ON reasoning_log(category);
-    CREATE INDEX IF NOT EXISTS idx_reasoning_importance ON reasoning_log(importance);
-
-    -- v8.1: Indices para Architectural Analyses
-    CREATE INDEX IF NOT EXISTS idx_arch_status ON architectural_analyses(status);
-    CREATE INDEX IF NOT EXISTS idx_arch_created ON architectural_analyses(created_at);
-
-    -- v8.5: Indices para Project Utilities
-    CREATE INDEX IF NOT EXISTS idx_utils_scope ON project_utilities(scope);
-    CREATE INDEX IF NOT EXISTS idx_utils_name ON project_utilities(utility_name);
-    CREATE INDEX IF NOT EXISTS idx_utils_file ON project_utilities(file_path);
+    )
   `);
 
-  // Executar migracoes versionadas
-  runMigrations();
+  // Indices
+  const indices = [
+    "CREATE INDEX IF NOT EXISTS idx_tasks_spec ON tasks(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)",
+    "CREATE INDEX IF NOT EXISTS idx_decisions_spec ON decisions(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_artifacts_spec ON artifacts(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_snapshots_spec ON snapshots(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_standards_category ON standards(category)",
+    "CREATE INDEX IF NOT EXISTS idx_standards_scope ON standards(scope)",
+    "CREATE INDEX IF NOT EXISTS idx_knowledge_spec ON knowledge(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_knowledge_category ON knowledge(category)",
+    "CREATE INDEX IF NOT EXISTS idx_knowledge_severity ON knowledge(severity)",
+    "CREATE INDEX IF NOT EXISTS idx_gate_bypasses_spec ON gate_bypasses(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_product_goals_product ON product_goals(product_id)",
+    "CREATE INDEX IF NOT EXISTS idx_product_goals_category ON product_goals(category)",
+    "CREATE INDEX IF NOT EXISTS idx_product_features_product ON product_features(product_id)",
+    "CREATE INDEX IF NOT EXISTS idx_product_features_priority ON product_features(priority)",
+    "CREATE INDEX IF NOT EXISTS idx_lib_contexts_lib ON lib_contexts(lib_name)",
+    "CREATE INDEX IF NOT EXISTS idx_agent_lib_mappings_agent ON agent_lib_mappings(agent_type)",
+    "CREATE INDEX IF NOT EXISTS idx_impl_patterns_category ON implementation_patterns(category)",
+    "CREATE INDEX IF NOT EXISTS idx_impl_patterns_scope ON implementation_patterns(scope)",
+    "CREATE INDEX IF NOT EXISTS idx_impl_patterns_name ON implementation_patterns(name)",
+    "CREATE INDEX IF NOT EXISTS idx_kg_source ON knowledge_graph(source_type, source_id)",
+    "CREATE INDEX IF NOT EXISTS idx_kg_target ON knowledge_graph(target_type, target_id)",
+    "CREATE INDEX IF NOT EXISTS idx_kg_relation ON knowledge_graph(relation)",
+    "CREATE INDEX IF NOT EXISTS idx_kg_spec ON knowledge_graph(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_reasoning_spec ON reasoning_log(spec_id)",
+    "CREATE INDEX IF NOT EXISTS idx_reasoning_task ON reasoning_log(task_id)",
+    "CREATE INDEX IF NOT EXISTS idx_reasoning_category ON reasoning_log(category)",
+    "CREATE INDEX IF NOT EXISTS idx_reasoning_importance ON reasoning_log(importance)",
+    "CREATE INDEX IF NOT EXISTS idx_arch_status ON architectural_analyses(status)",
+    "CREATE INDEX IF NOT EXISTS idx_arch_created ON architectural_analyses(created_at)",
+    "CREATE INDEX IF NOT EXISTS idx_utils_scope ON project_utilities(scope)",
+    "CREATE INDEX IF NOT EXISTS idx_utils_name ON project_utilities(utility_name)",
+    "CREATE INDEX IF NOT EXISTS idx_utils_file ON project_utilities(file_path)",
+  ];
+
+  const db = getDb();
+  await db.batch(
+    indices.map((sql) => ({ sql, args: [] })),
+    "write"
+  );
+
+  await runMigrations();
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -365,50 +328,50 @@ export function initSchema(): void {
 interface Migration {
   version: string;
   description: string;
-  up: (db: Database) => void;
+  up: () => Promise<void>;
 }
 
 const MIGRATIONS: Migration[] = [
   {
     version: "8.4.0",
     description: "Adicionar analysis_id na tabela specs",
-    up: (db) => {
-      db.exec(`ALTER TABLE specs ADD COLUMN analysis_id TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE specs ADD COLUMN analysis_id TEXT");
     },
   },
   {
     version: "8.7.0",
     description: "Adicionar cli_version na tabela project",
-    up: (db) => {
-      db.exec(`ALTER TABLE project ADD COLUMN cli_version TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE project ADD COLUMN cli_version TEXT");
     },
   },
   {
     version: "9.1.0",
     description: "Adicionar last_discover_at na tabela project",
-    up: (db) => {
-      db.exec(`ALTER TABLE project ADD COLUMN last_discover_at TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE project ADD COLUMN last_discover_at TEXT");
     },
   },
   {
     version: "9.1.1",
     description: "Remover tabela session_summaries",
-    up: (db) => {
-      db.exec(`DROP TABLE IF EXISTS session_summaries`);
+    up: async () => {
+      await dbExec("DROP TABLE IF EXISTS session_summaries");
     },
   },
   {
     version: "9.2.0",
     description: "Adicionar started_at na tabela tasks para validacao temporal de arquivos",
-    up: (db) => {
-      db.exec(`ALTER TABLE tasks ADD COLUMN started_at TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE tasks ADD COLUMN started_at TEXT");
     },
   },
   {
     version: "9.3.0",
     description: "Criar tabela agent_performance para feedback loop",
-    up: (db) => {
-      db.exec(`
+    up: async () => {
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS agent_performance (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           agent_type TEXT NOT NULL,
@@ -424,15 +387,15 @@ const MIGRATIONS: Migration[] = [
           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 INDEX IF NOT EXISTS idx_agent_perf_created ON agent_performance(created_at)`);
+      await dbExec("CREATE INDEX IF NOT EXISTS idx_agent_perf_type ON agent_performance(agent_type)");
+      await dbExec("CREATE INDEX IF NOT EXISTS idx_agent_perf_created ON agent_performance(created_at)");
     },
   },
   {
     version: "9.4.0",
     description: "Migrar acknowledged_by de JSON para tabela separada",
-    up: (db) => {
-      db.exec(`
+    up: async () => {
+      await dbExec(`
         CREATE TABLE IF NOT EXISTS knowledge_acknowledgments (
           knowledge_id INTEGER NOT NULL REFERENCES knowledge(id) ON DELETE CASCADE,
           task_id INTEGER NOT NULL,
@@ -440,96 +403,92 @@ const MIGRATIONS: Migration[] = [
           PRIMARY KEY (knowledge_id, task_id)
         )
       `);
-      db.exec(`CREATE INDEX IF NOT EXISTS idx_ka_task ON knowledge_acknowledgments(task_id)`);
-
-      // Migrar dados existentes do campo JSON
-      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) {
-        try {
-          const taskIds = JSON.parse(row.acknowledged_by) as number[];
-          for (const taskId of taskIds) {
-            insert.run(row.id, taskId);
-          }
-        } catch { /* JSON invalido, ignorar */ }
-      }
+      await dbExec("CREATE INDEX IF NOT EXISTS idx_ka_task ON knowledge_acknowledgments(task_id)");
+
+      try {
+        const rows = await dbAll<any>("SELECT id, acknowledged_by FROM knowledge WHERE acknowledged_by IS NOT NULL");
+        for (const row of rows) {
+          try {
+            const taskIds = JSON.parse(row.acknowledged_by) as number[];
+            for (const taskId of taskIds) {
+              await dbRun("INSERT OR IGNORE INTO knowledge_acknowledgments (knowledge_id, task_id) VALUES (?, ?)", [row.id, taskId]);
+            }
+          } catch { /* JSON invalido, ignorar */ }
+        }
+      } catch { /* Coluna acknowledged_by nao existe em DB fresh */ }
     },
   },
   {
     version: "9.5.0",
     description: "Adicionar superseded_by na tabela decisions",
-    up: (db) => {
-      db.exec(`ALTER TABLE decisions ADD COLUMN superseded_by TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE decisions ADD COLUMN superseded_by TEXT");
     },
   },
   {
     version: "9.6.0",
     description: "Adicionar semantic_query e expect na tabela standards para validacao semantica stack-agnostica",
-    up: (db) => {
-      db.exec(`ALTER TABLE standards ADD COLUMN semantic_query TEXT`);
-      db.exec(`ALTER TABLE standards ADD COLUMN expect TEXT DEFAULT 'no_match'`);
+    up: async () => {
+      await dbExec("ALTER TABLE standards ADD COLUMN semantic_query TEXT");
+      await dbExec("ALTER TABLE standards ADD COLUMN expect TEXT DEFAULT 'no_match'");
     },
   },
   {
     version: "9.7.0",
     description: "Adicionar typecheck_command na tabela project para typecheck agnostico de stack",
-    up: (db) => {
-      db.exec(`ALTER TABLE project ADD COLUMN typecheck_command TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE project ADD COLUMN typecheck_command TEXT");
     },
   },
   {
     version: "9.8.0",
     description: "Adicionar grepai_workspace na tabela project para suporte a workspace cross-project",
-    up: (db) => {
-      db.exec(`ALTER TABLE project ADD COLUMN grepai_workspace TEXT`);
+    up: async () => {
+      await dbExec("ALTER TABLE project ADD COLUMN grepai_workspace TEXT");
     },
   },
   {
     version: "9.9.0",
     description: "Adicionar suporte a fases: phase em tasks, total_phases/current_phase em context",
-    up: (db) => {
-      db.exec(`ALTER TABLE tasks ADD COLUMN phase INTEGER DEFAULT 1`);
-      db.exec(`ALTER TABLE context ADD COLUMN total_phases INTEGER DEFAULT 1`);
-      db.exec(`ALTER TABLE context ADD COLUMN current_phase INTEGER DEFAULT 1`);
+    up: async () => {
+      await dbExec("ALTER TABLE tasks ADD COLUMN phase INTEGER DEFAULT 1");
+      await dbExec("ALTER TABLE context ADD COLUMN total_phases INTEGER DEFAULT 1");
+      await dbExec("ALTER TABLE context ADD COLUMN current_phase INTEGER DEFAULT 1");
     },
   },
   {
     version: "10.1.0",
     description: "Adicionar auto_simplify na tabela project para simplificacao automatica pos-task",
-    up: (db) => {
-      db.exec(`ALTER TABLE project ADD COLUMN auto_simplify INTEGER DEFAULT 0`);
+    up: async () => {
+      await dbExec("ALTER TABLE project ADD COLUMN auto_simplify INTEGER DEFAULT 0");
     },
   },
   {
     version: "10.3.0",
     description: "Remover colunas mortas: review.pattern_violations, review.resolution, knowledge.acknowledged_by, decisions.superseded_by",
-    up: (db) => {
-      db.exec(`ALTER TABLE review DROP COLUMN pattern_violations`);
-      db.exec(`ALTER TABLE review DROP COLUMN resolution`);
-      db.exec(`ALTER TABLE knowledge DROP COLUMN acknowledged_by`);
-      db.exec(`ALTER TABLE decisions DROP COLUMN superseded_by`);
+    up: async () => {
+      for (const stmt of [
+        "ALTER TABLE review DROP COLUMN pattern_violations",
+        "ALTER TABLE review DROP COLUMN resolution",
+        "ALTER TABLE knowledge DROP COLUMN acknowledged_by",
+        "ALTER TABLE decisions DROP COLUMN superseded_by",
+      ]) {
+        try { await dbExec(stmt); } catch { /* Coluna pode nao existir em DB fresh */ }
+      }
     },
   },
 ];
 
-export function runMigrations(): void {
-  const db = getDb();
-
+export async function runMigrations(): Promise<void> {
   for (const migration of MIGRATIONS) {
-    // Verificar se ja foi aplicada
-    const existing = db
-      .query("SELECT version FROM schema_migrations WHERE version = ?")
-      .get(migration.version);
-
+    const existing = await dbGet("SELECT version FROM schema_migrations WHERE version = ?", [migration.version]);
     if (existing) continue;
 
-    // Executar migracao
     try {
-      migration.up(db);
+      await migration.up();
     } catch (e: any) {
       const msg = (e as Error).message || "";
-      // "duplicate column name" e esperado em DBs criadas antes do sistema de migracoes
-      if (msg.includes("duplicate column name") || msg.includes("already exists")) {
+      if (msg.includes("duplicate column name") || msg.includes("already exists") || msg.includes("no such column")) {
         // Marcar como aplicada mesmo assim — DB ja tem a mudanca
       } else {
         throw new Error(
@@ -539,60 +498,31 @@ export function runMigrations(): void {
       }
     }
 
-    // Registrar migracao como aplicada
     const now = new Date().toISOString();
-    db.run(
+    await dbRun(
       "INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)",
       [migration.version, migration.description, now]
     );
   }
 }
 
-// Exportar MIGRATIONS para testes
 export { MIGRATIONS };
 
 // ═══════════════════════════════════════════════════════════════
 // v10.2: Transacao Atomica Helper
-// Wrapa qualquer operacao em BEGIN IMMEDIATE / COMMIT com
-// rollback automatico em caso de erro.
-// BEGIN IMMEDIATE garante lock exclusivo para escrita desde o
-// inicio, evitando deadlocks em WAL mode.
 // ═══════════════════════════════════════════════════════════════
 
-const MAX_BUSY_RETRIES = 3;
-const BUSY_RETRY_BASE_MS = 50;
-
-export function runInTransaction<T>(fn: () => T): T {
+export async function runInTransaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T> {
   const db = getDb();
-  let retries = MAX_BUSY_RETRIES;
-
-  while (retries > 0) {
-    try {
-      db.exec("BEGIN IMMEDIATE");
-      break;
-    } catch (e: any) {
-      if (e.message?.includes("SQLITE_BUSY") && retries > 1) {
-        retries--;
-        const delay = BUSY_RETRY_BASE_MS * (MAX_BUSY_RETRIES - retries);
-        Bun.sleepSync(delay);
-        continue;
-      }
-      throw e;
-    }
-  }
 
-  try {
-    const result = fn();
-    db.exec("COMMIT");
-    return result;
-  } catch (e) {
-    try { db.exec("ROLLBACK"); } catch { /* already rolled back */ }
-    throw e;
-  }
+  // Inner functions use dbRun/dbGet/dbAll (global client) instead of tx directly.
+  // With @libsql/client, wrapping in a real transaction and swapping the global client
+  // breaks :memory: DBs (connection becomes invalid after tx.commit).
+  // Since the inner functions already use the global helpers, we run without a real
+  // transaction wrapper. The client-level execute is already serialized by @libsql/client.
+  return await fn(db as unknown as Transaction);
 }
 
-// Gera proximo ID de decisao para um spec
-// Usa timestamp + random hash para eliminar race conditions entre tasks paralelas
 export function getNextDecisionId(specId: string): string {
   const slug = specId.split("-").slice(1, 3).join("-");
   const ts = Date.now().toString(36);
@@ -600,25 +530,22 @@ export function getNextDecisionId(specId: string): string {
   return `DEC-${slug}-${ts}-${rand}`;
 }
 
-// Claim atomico de task: retorna true se task estava pending e agora esta running.
-// Retorna false se outra instancia ja pegou a task.
-export function claimTask(taskId: number): boolean {
-  const db = getDb();
+export async function claimTask(taskId: number): Promise<boolean> {
   const now = new Date().toISOString();
-  const result = db.run(
+  const result = await dbRun(
     "UPDATE tasks SET status = 'running', started_at = ? WHERE id = ? AND status = 'pending'",
     [now, taskId]
   );
   return result.changes > 0;
 }
 
-const STUCK_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutos
+const STUCK_THRESHOLD_MS = 30 * 60 * 1000;
 
-export function detectStuckTasks(specId: string): any[] {
-  const db = getDb();
-  const running = db.query(
-    "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running'"
-  ).all(specId) as any[];
+export async function detectStuckTasks(specId: string): Promise<any[]> {
+  const running = await dbAll(
+    "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running'",
+    [specId]
+  );
 
   const now = Date.now();
   return running.filter((task: any) => {
@@ -628,24 +555,22 @@ export function detectStuckTasks(specId: string): any[] {
   });
 }
 
-export function getPatternsByScope(scope: string): any[] {
-  const db = getDb();
-  return db.query(
-    "SELECT * FROM implementation_patterns WHERE scope = ? OR scope = 'all' ORDER BY category, name"
-  ).all(scope) as any[];
+export async function getPatternsByScope(scope: string): Promise<any[]> {
+  return dbAll(
+    "SELECT * FROM implementation_patterns WHERE scope = ? OR scope = 'all' ORDER BY category, name",
+    [scope]
+  );
 }
 
-export function getPatternsForFiles(files: string[]): any[] {
-  const db = getDb();
+export async function getPatternsForFiles(files: string[]): Promise<any[]> {
   if (files.length === 0) return [];
 
-  // Pre-filtrar no SQL usando extensoes e diretorios para reduzir candidatos
   const extensions = new Set<string>();
   const dirs = new Set<string>();
   for (const f of files) {
-    const ext = f.split('.').pop();
+    const ext = f.split(".").pop();
     if (ext) extensions.add(ext);
-    const parts = f.split('/');
+    const parts = f.split("/");
     for (let i = 0; i < parts.length - 1; i++) {
       dirs.add(parts[i]);
     }
@@ -662,20 +587,18 @@ export function getPatternsForFiles(files: string[]): any[] {
     params.push(`%${dir}%`);
   }
 
-  // Se nao ha condicoes, buscar tudo (fallback)
   const candidates = conditions.length > 0
-    ? db.query(`SELECT * FROM implementation_patterns WHERE ${conditions.join(' OR ')}`).all(...params) as any[]
-    : db.query("SELECT * FROM implementation_patterns").all() as any[];
+    ? await dbAll(`SELECT * FROM implementation_patterns WHERE ${conditions.join(" OR ")}`, params)
+    : await dbAll("SELECT * FROM implementation_patterns");
 
-  // Regex match apenas nos candidatos pre-filtrados
-  return candidates.filter(pattern => {
+  return candidates.filter((pattern: any) => {
     const glob = pattern.applies_to;
     const regexPattern = glob
-      .replace(/\*\*/g, '.*')
-      .replace(/\*/g, '[^/]*')
-      .replace(/\//g, '\\/');
+      .replace(/\*\*/g, ".*")
+      .replace(/\*/g, "[^/]*")
+      .replace(/\//g, "\\/");
     const regex = new RegExp(`^${regexPattern}$`);
-    return files.some(file => regex.test(file));
+    return files.some((file) => regex.test(file));
   });
 }
 
@@ -692,11 +615,9 @@ export interface GraphRelation {
   metadata?: Record<string, any>;
 }
 
-export function addGraphRelation(specId: string | null, relation: GraphRelation): void {
-  const db = getDb();
+export async function addGraphRelation(specId: string | null, relation: GraphRelation): Promise<void> {
   const now = new Date().toISOString();
-
-  db.run(
+  await dbRun(
     `INSERT INTO knowledge_graph (spec_id, source_type, source_id, target_type, target_id, relation, metadata, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
     [
@@ -712,28 +633,25 @@ export function addGraphRelation(specId: string | null, relation: GraphRelation)
   );
 }
 
-export function getRelatedDecisions(fileOrPattern: string, type: "file" | "pattern"): any[] {
-  const db = getDb();
-
-  return db.query(`
-    SELECT d.* FROM decisions d
+export async function getRelatedDecisions(fileOrPattern: string, type: "file" | "pattern"): Promise<any[]> {
+  return dbAll(
+    `SELECT d.* FROM decisions d
     JOIN knowledge_graph kg ON kg.source_id = d.id AND kg.source_type = 'decision'
     WHERE kg.target_type = ? AND kg.target_id = ?
-    AND kg.relation IN ('implements', 'depends_on', 'uses')
-  `).all(type, fileOrPattern) as any[];
+    AND kg.relation IN ('implements', 'depends_on', 'uses')`,
+    [type, fileOrPattern]
+  );
 }
 
-export function getRelatedFiles(decisionOrPattern: string, type: "decision" | "pattern"): string[] {
-  const db = getDb();
-
-  const results = db.query(`
-    SELECT kg.target_id as file FROM knowledge_graph kg
+export async function getRelatedFiles(decisionOrPattern: string, type: "decision" | "pattern"): Promise<string[]> {
+  const results = await dbAll(
+    `SELECT kg.target_id as file FROM knowledge_graph kg
     WHERE kg.source_type = ? AND kg.source_id = ?
     AND kg.target_type = 'file'
-    AND kg.relation IN ('implements', 'modifies', 'creates')
-  `).all(type, decisionOrPattern) as any[];
-
-  return results.map(r => r.file);
+    AND kg.relation IN ('implements', 'modifies', 'creates')`,
+    [type, decisionOrPattern]
+  );
+  return results.map((r: any) => r.file);
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -749,11 +667,9 @@ export interface ReasoningEntry {
   importance?: "critical" | "high" | "normal" | "low";
 }
 
-export function addReasoning(specId: string, taskId: number | null, entry: ReasoningEntry): void {
-  const db = getDb();
+export async function addReasoning(specId: string, taskId: number | null, entry: ReasoningEntry): Promise<void> {
   const now = new Date().toISOString();
-
-  db.run(
+  await dbRun(
     `INSERT INTO reasoning_log (spec_id, task_id, category, thought, related_files, related_decisions, related_patterns, importance, created_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     [
@@ -770,49 +686,39 @@ export function addReasoning(specId: string, taskId: number | null, entry: Reaso
   );
 }
 
-export function getRecentReasoning(specId: string, limit: number = 20): any[] {
-  const db = getDb();
-
-  return db.query(`
-    SELECT * FROM reasoning_log
-    WHERE spec_id = ?
-    ORDER BY created_at DESC
-    LIMIT ?
-  `).all(specId, limit) as any[];
+export async function getRecentReasoning(specId: string, limit: number = 20): Promise<any[]> {
+  return dbAll(
+    "SELECT * FROM reasoning_log WHERE spec_id = ? ORDER BY created_at DESC LIMIT ?",
+    [specId, limit]
+  );
 }
 
-// v8.4: Busca analise arquitetural associada a um spec
-// Prioridade: analysis_id (link explicito) > nome exato > LIKE parcial
-export function getArchitecturalAnalysisForSpec(specName: string, specId?: string): any {
-  const db = getDb();
-
+export async function getArchitecturalAnalysisForSpec(specName: string, specId?: string): Promise<any> {
   try {
-    // 0. Link explicito via analysis_id na tabela specs
     if (specId) {
-      const spec = db.query("SELECT analysis_id FROM specs WHERE id = ?").get(specId) as any;
+      const spec = await dbGet<any>("SELECT analysis_id FROM specs WHERE id = ?", [specId]);
       if (spec?.analysis_id) {
-        const analysis = db.query(
-          "SELECT * FROM architectural_analyses WHERE id = ? AND status IN ('approved', 'implemented')"
-        ).get(spec.analysis_id) as any;
+        const analysis = await dbGet(
+          "SELECT * FROM architectural_analyses WHERE id = ? AND status IN ('approved', 'implemented')",
+          [spec.analysis_id]
+        );
         if (analysis) return analysis;
       }
     }
 
-    // 1. Match exato por nome
-    let analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE name = ? AND status IN ('approved', 'implemented') ORDER BY approved_at DESC LIMIT 1"
-    ).get(specName) as any;
-
+    let analysis = await dbGet(
+      "SELECT * FROM architectural_analyses WHERE name = ? AND status IN ('approved', 'implemented') ORDER BY approved_at DESC LIMIT 1",
+      [specName]
+    );
     if (analysis) return analysis;
 
-    // 2. Match parcial (nome da spec contido no nome da analise ou vice-versa)
-    analysis = db.query(
-      "SELECT * FROM architectural_analyses WHERE (name LIKE ? OR ? LIKE '%' || name || '%') AND status IN ('approved', 'implemented') ORDER BY approved_at DESC LIMIT 1"
-    ).get(`%${specName}%`, specName) as any;
+    analysis = await dbGet(
+      "SELECT * FROM architectural_analyses WHERE (name LIKE ? OR ? LIKE '%' || name || '%') AND status IN ('approved', 'implemented') ORDER BY approved_at DESC LIMIT 1",
+      [`%${specName}%`, specName]
+    );
 
     return analysis || null;
   } catch {
-    // Tabela pode nao existir se architect nunca foi usado
     return null;
   }
 }
@@ -830,14 +736,13 @@ export interface ProjectUtility {
   description?: string;
 }
 
-export function upsertUtility(
+export async function upsertUtility(
   utility: ProjectUtility,
   specId?: string,
   taskRef?: number
-): void {
-  const db = getDb();
+): Promise<void> {
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     `INSERT INTO project_utilities (file_path, utility_name, utility_type, scope, signature, description, spec_id, task_ref, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(file_path, utility_name) DO UPDATE SET
@@ -854,21 +759,18 @@ export function upsertUtility(
   );
 }
 
-export function getUtilitiesForContext(
+export async function getUtilitiesForContext(
   dirs: string[],
   scope?: string,
   limit: number = 15
-): any[] {
-  const db = getDb();
-
-  // Se nenhum filtro, retornar mais recentes
+): Promise<any[]> {
   if (dirs.length === 0 && !scope) {
-    return db.query(
-      "SELECT * FROM project_utilities ORDER BY updated_at DESC LIMIT ?"
-    ).all(limit) as any[];
+    return dbAll(
+      "SELECT * FROM project_utilities ORDER BY updated_at DESC LIMIT ?",
+      [limit]
+    );
   }
 
-  // Buscar por diretorio (prioridade) e scope (fallback)
   const conditions: string[] = [];
   const params: any[] = [];
 
@@ -885,24 +787,26 @@ export function getUtilitiesForContext(
 
   params.push(limit);
   const where = conditions.length > 0 ? `WHERE (${conditions.join(" OR ")})` : "";
-  return db.query(
-    `SELECT * FROM project_utilities ${where} ORDER BY updated_at DESC LIMIT ?`
-  ).all(...params) as any[];
+  return dbAll(
+    `SELECT * FROM project_utilities ${where} ORDER BY updated_at DESC LIMIT ?`,
+    params
+  );
 }
 
-export function findDuplicateUtilities(
+export async function findDuplicateUtilities(
   utilityName: string,
   excludeFile?: string
-): any[] {
-  const db = getDb();
+): Promise<any[]> {
   if (excludeFile) {
-    return db.query(
-      "SELECT * FROM project_utilities WHERE utility_name = ? AND file_path != ?"
-    ).all(utilityName, excludeFile) as any[];
+    return dbAll(
+      "SELECT * FROM project_utilities WHERE utility_name = ? AND file_path != ?",
+      [utilityName, excludeFile]
+    );
   }
-  return db.query(
-    "SELECT * FROM project_utilities WHERE utility_name = ?"
-  ).all(utilityName) as any[];
+  return dbAll(
+    "SELECT * FROM project_utilities WHERE utility_name = ?",
+    [utilityName]
+  );
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -922,10 +826,9 @@ export interface AgentPerformanceData {
   executionDurationMs: number;
 }
 
-export function recordAgentPerformance(data: AgentPerformanceData): void {
-  const db = getDb();
+export async function recordAgentPerformance(data: AgentPerformanceData): Promise<void> {
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     `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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -938,16 +841,16 @@ export function recordAgentPerformance(data: AgentPerformanceData): void {
   );
 }
 
-export function getAgentHints(agentType: string, limit: number = 5): string[] {
-  const db = getDb();
+export async function getAgentHints(agentType: string, limit: number = 5): Promise<string[]> {
   const hints: string[] = [];
 
   try {
-    const recent = db.query(
+    const recent = await dbAll(
       `SELECT * FROM agent_performance
        WHERE agent_type = ?
-       ORDER BY created_at DESC LIMIT ?`
-    ).all(agentType, limit) as any[];
+       ORDER BY created_at DESC LIMIT ?`,
+      [agentType, limit]
+    );
 
     if (recent.length === 0) return [];
 
@@ -964,17 +867,18 @@ export function getAgentHints(agentType: string, limit: number = 5): string[] {
       hints.push(`ATENCAO: Gate pass rate baixo (${(avgGateRate * 100).toFixed(0)}%). Verifique standards e DRY obrigatorios.`);
     }
 
-    const bypassTypes = db.query(
+    const bypassTypes = await dbAll(
       `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(agentType) as any[];
+       ORDER BY cnt DESC LIMIT 3`,
+      [agentType]
+    );
 
     for (const bp of bypassTypes) {
-      if (bp.cnt >= 2) {
-        hints.push(`Gate '${bp.gate_name}' frequentemente ignorado (${bp.cnt}x). Preste atencao especial.`);
+      if ((bp as any).cnt >= 2) {
+        hints.push(`Gate '${(bp as any).gate_name}' frequentemente ignorado (${(bp as any).cnt}x). Preste atencao especial.`);
       }
     }
   } catch {