@codexa/cli 9.0.2 → 9.0.3

package/db/schema.test.ts

@@ -0,0 +1,333 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { mkdirSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+
+// Setup: use a temporary directory for test databases
+const TEST_DIR = join(import.meta.dir, "..", ".test-db");
+const TEST_DB_PATH = join(TEST_DIR, "test.db");
+
+// We need to override the DB path before importing schema functions.
+// The connection module uses process.cwd() so we mock via direct DB manipulation.
+
+describe("Migration System", () => {
+  let db: Database;
+
+  beforeEach(() => {
+    // Create in-memory database with same schema setup
+    db = new Database(":memory:");
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  function createBaseTables(db: Database) {
+    // Minimal table creation to test migrations against
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS specs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        phase TEXT NOT NULL DEFAULT 'planning',
+        approved_at TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS project (
+        id TEXT PRIMARY KEY DEFAULT 'default',
+        name TEXT,
+        stack TEXT NOT NULL,
+        discovered_at TEXT,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        spec_id TEXT NOT NULL REFERENCES specs(id),
+        number INTEGER NOT NULL,
+        name TEXT NOT NULL,
+        depends_on TEXT,
+        can_parallel INTEGER DEFAULT 1,
+        agent TEXT,
+        files TEXT,
+        status TEXT DEFAULT 'pending',
+        checkpoint TEXT,
+        completed_at TEXT,
+        UNIQUE(spec_id, number)
+      );
+
+      CREATE TABLE IF NOT EXISTS decisions (
+        id TEXT PRIMARY KEY,
+        spec_id TEXT NOT NULL REFERENCES specs(id),
+        task_ref INTEGER,
+        title TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        rationale TEXT,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        applied_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // runMigrations() tests
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("runMigrations()", () => {
+    it("should apply all migrations on a fresh database", () => {
+      createBaseTables(db);
+
+      // Define test migrations
+      const migrations = [
+        {
+          version: "8.4.0",
+          description: "Add analysis_id to specs",
+          up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+        },
+        {
+          version: "8.7.0",
+          description: "Add cli_version to project",
+          up: (d: Database) => d.exec("ALTER TABLE project ADD COLUMN cli_version TEXT"),
+        },
+      ];
+
+      // Run migrations manually (simulating runMigrations logic)
+      for (const migration of migrations) {
+        const existing = db.query("SELECT version FROM schema_migrations WHERE version = ?").get(migration.version);
+        if (existing) continue;
+
+        migration.up(db);
+        db.run(
+          "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
+          [migration.version, migration.description]
+        );
+      }
+
+      // Verify all migrations were recorded
+      const applied = db.query("SELECT * FROM schema_migrations ORDER BY version").all() as any[];
+      expect(applied.length).toBe(2);
+      expect(applied[0].version).toBe("8.4.0");
+      expect(applied[1].version).toBe("8.7.0");
+
+      // Verify columns were added
+      const columns = db.query("PRAGMA table_info(specs)").all() as any[];
+      const colNames = columns.map((c: any) => c.name);
+      expect(colNames).toContain("analysis_id");
+    });
+
+    it("should be idempotent — calling twice applies each migration only once", () => {
+      createBaseTables(db);
+
+      const migration = {
+        version: "8.4.0",
+        description: "Add analysis_id to specs",
+        up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+      };
+
+      // First run
+      migration.up(db);
+      db.run(
+        "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
+        [migration.version, migration.description]
+      );
+
+      // Second run — should skip because already applied
+      const existing = db.query("SELECT version FROM schema_migrations WHERE version = ?").get(migration.version);
+      expect(existing).not.toBeNull();
+
+      // Verify only 1 record
+      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
+      expect(applied.c).toBe(1);
+    });
+
+    it("should absorb 'duplicate column name' errors from pre-migration databases", () => {
+      createBaseTables(db);
+
+      // Manually add the column first (simulating pre-migration DB)
+      db.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT");
+
+      // Now try to run the migration — should NOT throw
+      const migration = {
+        version: "8.4.0",
+        description: "Add analysis_id to specs",
+        up: (d: Database) => d.exec("ALTER TABLE specs ADD COLUMN analysis_id TEXT"),
+      };
+
+      let absorbed = false;
+      try {
+        migration.up(db);
+      } catch (e: any) {
+        if (e.message.includes("duplicate column name")) {
+          absorbed = true;
+        } else {
+          throw e;
+        }
+      }
+
+      expect(absorbed).toBe(true);
+
+      // Record it anyway
+      db.run(
+        "INSERT INTO schema_migrations (version, description) VALUES (?, ?)",
+        [migration.version, migration.description]
+      );
+
+      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
+      expect(applied.c).toBe(1);
+    });
+
+    it("should propagate real errors (not duplicate column)", () => {
+      createBaseTables(db);
+
+      const badMigration = {
+        version: "99.0.0",
+        description: "Bad migration",
+        up: (d: Database) => d.exec("ALTER TABLE nonexistent_table ADD COLUMN foo TEXT"),
+      };
+
+      expect(() => {
+        badMigration.up(db);
+      }).toThrow();
+
+      // Migration should NOT be recorded
+      const applied = db.query("SELECT COUNT(*) as c FROM schema_migrations").get() as any;
+      expect(applied.c).toBe(0);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // getNextDecisionId() tests
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("getNextDecisionId()", () => {
+    function getNextDecisionId(specId: string): string {
+      const result = db.query(
+        `SELECT MAX(CAST(REPLACE(id, 'DEC-', '') AS INTEGER)) as max_num
+         FROM decisions WHERE spec_id = ?`
+      ).get(specId) as any;
+
+      const nextNum = (result?.max_num || 0) + 1;
+      return `DEC-${nextNum.toString().padStart(3, "0")}`;
+    }
+
+    beforeEach(() => {
+      createBaseTables(db);
+      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'planning')");
+    });
+
+    it("should return DEC-001 for empty decisions", () => {
+      expect(getNextDecisionId("SPEC-001")).toBe("DEC-001");
+    });
+
+    it("should return sequential IDs", () => {
+      const now = new Date().toISOString();
+      db.run(
+        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
+        ["DEC-001", "SPEC-001", "test", "test", now]
+      );
+      expect(getNextDecisionId("SPEC-001")).toBe("DEC-002");
+
+      db.run(
+        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
+        ["DEC-002", "SPEC-001", "test2", "test2", now]
+      );
+      expect(getNextDecisionId("SPEC-001")).toBe("DEC-003");
+    });
+
+    it("should handle gaps in IDs (e.g., DEC-001, DEC-003 → DEC-004)", () => {
+      const now = new Date().toISOString();
+      db.run(
+        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
+        ["DEC-001", "SPEC-001", "test", "test", now]
+      );
+      db.run(
+        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
+        ["DEC-003", "SPEC-001", "test3", "test3", now]
+      );
+      expect(getNextDecisionId("SPEC-001")).toBe("DEC-004");
+    });
+
+    it("should scope to spec — different specs have independent IDs", () => {
+      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-002', 'other', 'planning')");
+      const now = new Date().toISOString();
+      db.run(
+        "INSERT INTO decisions (id, spec_id, title, decision, created_at) VALUES (?, ?, ?, ?, ?)",
+        ["DEC-005", "SPEC-001", "test", "test", now]
+      );
+
+      expect(getNextDecisionId("SPEC-001")).toBe("DEC-006");
+      expect(getNextDecisionId("SPEC-002")).toBe("DEC-001");
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════
+  // claimTask() tests
+  // ═══════════════════════════════════════════════════════════════
+
+  describe("claimTask()", () => {
+    function claimTask(taskId: number): boolean {
+      const result = db.run(
+        "UPDATE tasks SET status = 'running' WHERE id = ? AND status = 'pending'",
+        [taskId]
+      );
+      return result.changes > 0;
+    }
+
+    beforeEach(() => {
+      createBaseTables(db);
+      db.run("INSERT INTO specs (id, name, phase) VALUES ('SPEC-001', 'test', 'implementing')");
+      db.run(
+        "INSERT INTO tasks (spec_id, number, name, status) VALUES (?, ?, ?, ?)",
+        ["SPEC-001", 1, "Test task", "pending"]
+      );
+    });
+
+    it("should return true and set status to running for a pending task", () => {
+      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+      expect(claimTask(taskId)).toBe(true);
+
+      const task = db.query("SELECT status FROM tasks WHERE id = ?").get(taskId) as any;
+      expect(task.status).toBe("running");
+    });
+
+    it("should return false for a task already in running status", () => {
+      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+
+      // First claim succeeds
+      expect(claimTask(taskId)).toBe(true);
+      // Second claim fails
+      expect(claimTask(taskId)).toBe(false);
+    });
+
+    it("should return false for a task in done status", () => {
+      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+      db.run("UPDATE tasks SET status = 'done' WHERE id = ?", [taskId]);
+
+      expect(claimTask(taskId)).toBe(false);
+    });
+
+    it("should return false for a non-existent task ID", () => {
+      expect(claimTask(99999)).toBe(false);
+    });
+
+    it("should prevent double-claim (only first caller wins)", () => {
+      const taskId = (db.query("SELECT id FROM tasks WHERE number = 1").get() as any).id;
+
+      // Simulate two concurrent claims
+      const claim1 = claimTask(taskId);
+      const claim2 = claimTask(taskId);
+
+      expect(claim1).toBe(true);
+      expect(claim2).toBe(false);
+    });
+  });
+});

package/db/schema.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite";
 import { getDb } from "./connection";
 
 export function initSchema(): void {
@@ -263,30 +264,7 @@ export function initSchema(): void {
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
     );
 
-    -- 20. Session Summaries (v8.0 - Resumos de sessao para continuidade)
-    CREATE TABLE IF NOT EXISTS session_summaries (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      spec_id TEXT NOT NULL REFERENCES specs(id),
-
-      -- Periodo
-      start_time TEXT NOT NULL,
-      end_time TEXT NOT NULL,
-
-      -- Conteudo
-      summary TEXT NOT NULL,      -- O que foi feito
-      decisions TEXT,             -- JSON array de decisoes tomadas
-      blockers TEXT,              -- JSON array de problemas encontrados
-      next_steps TEXT,            -- JSON array de recomendacoes
-
-      -- Estatisticas
-      tasks_completed INTEGER DEFAULT 0,
-      files_created INTEGER DEFAULT 0,
-      files_modified INTEGER DEFAULT 0,
-
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP
-    );
-
-    -- 21. Architectural Analyses (v8.1 - migrado de architect.ts para schema central)
+    -- 20. Architectural Analyses (v8.1 - migrado de architect.ts para schema central)
     CREATE TABLE IF NOT EXISTS architectural_analyses (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
@@ -329,6 +307,13 @@ export function initSchema(): void {
       UNIQUE(file_path, utility_name)
     );
 
+    -- 23. Schema Migrations tracking (v9.2)
+    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);
@@ -363,10 +348,6 @@ export function initSchema(): void {
     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.0: Indices para Session Summaries
-    CREATE INDEX IF NOT EXISTS idx_session_spec ON session_summaries(spec_id);
-    CREATE INDEX IF NOT EXISTS idx_session_time ON session_summaries(end_time);
-
     -- 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);
@@ -377,21 +358,124 @@ export function initSchema(): void {
     CREATE INDEX IF NOT EXISTS idx_utils_file ON project_utilities(file_path);
   `);
 
-  // v8.4: Migracao - adicionar analysis_id na tabela specs
-  try {
-    db.exec(`ALTER TABLE specs ADD COLUMN analysis_id TEXT`);
-  } catch {
-    // Coluna ja existe - ignorar
-  }
+  // Executar migracoes versionadas
+  runMigrations();
+}
 
-  // v8.7: Migracao - adicionar cli_version na tabela project
-  try {
-    db.exec(`ALTER TABLE project ADD COLUMN cli_version TEXT`);
-  } catch {
-    // Coluna ja existe - ignorar
+// ═══════════════════════════════════════════════════════════════
+// v9.2: Sistema de Migracoes Versionado
+// ═══════════════════════════════════════════════════════════════
+
+interface Migration {
+  version: string;
+  description: string;
+  up: (db: Database) => 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`);
+    },
+  },
+  {
+    version: "8.7.0",
+    description: "Adicionar cli_version na tabela project",
+    up: (db) => {
+      db.exec(`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`);
+    },
+  },
+  {
+    version: "9.1.1",
+    description: "Remover tabela session_summaries",
+    up: (db) => {
+      db.exec(`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`);
+    },
+  },
+];
+
+export function runMigrations(): void {
+  const db = getDb();
+
+  for (const migration of MIGRATIONS) {
+    // Verificar se ja foi aplicada
+    const existing = db
+      .query("SELECT version FROM schema_migrations WHERE version = ?")
+      .get(migration.version);
+
+    if (existing) continue;
+
+    // Executar migracao
+    try {
+      migration.up(db);
+    } 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")) {
+        // Marcar como aplicada mesmo assim — DB ja tem a mudanca
+      } else {
+        throw new Error(
+          `Migracao ${migration.version} falhou: ${msg}\n` +
+          `Descricao: ${migration.description}`
+        );
+      }
+    }
+
+    // Registrar migracao como aplicada
+    const now = new Date().toISOString();
+    db.run(
+      "INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)",
+      [migration.version, migration.description, now]
+    );
   }
 }
 
+// Exportar MIGRATIONS para testes
+export { MIGRATIONS };
+
+// Gera proximo ID de decisao para um spec (DEC-001, DEC-002, ...)
+// Usa MAX() atomico para evitar race condition entre tasks paralelas
+export function getNextDecisionId(specId: string): string {
+  const db = getDb();
+  const result = db
+    .query(
+      `SELECT MAX(CAST(REPLACE(id, 'DEC-', '') AS INTEGER)) as max_num
+       FROM decisions WHERE spec_id = ?`
+    )
+    .get(specId) as any;
+
+  const nextNum = (result?.max_num || 0) + 1;
+  return `DEC-${nextNum.toString().padStart(3, "0")}`;
+}
+
+// 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();
+  const now = new Date().toISOString();
+  const result = db.run(
+    "UPDATE tasks SET status = 'running', started_at = ? WHERE id = ? AND status = 'pending'",
+    [now, taskId]
+  );
+  return result.changes > 0;
+}
+
 export function getPatternsByScope(scope: string): any[] {
   const db = getDb();
   return db.query(
@@ -401,21 +485,45 @@ export function getPatternsByScope(scope: string): any[] {
 
 export function getPatternsForFiles(files: string[]): any[] {
   const db = getDb();
-  const patterns = db.query("SELECT * FROM implementation_patterns").all() as 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();
+    if (ext) extensions.add(ext);
+    const parts = f.split('/');
+    for (let i = 0; i < parts.length - 1; i++) {
+      dirs.add(parts[i]);
+    }
+  }
+
+  const conditions: string[] = [];
+  const params: string[] = [];
+  for (const ext of extensions) {
+    conditions.push("applies_to LIKE ?");
+    params.push(`%${ext}%`);
+  }
+  for (const dir of dirs) {
+    conditions.push("applies_to LIKE ?");
+    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[];
 
-  // Filtrar patterns que correspondem aos arquivos da task
-  return patterns.filter(pattern => {
+  // Regex match apenas nos candidatos pre-filtrados
+  return candidates.filter(pattern => {
     const glob = pattern.applies_to;
-    return files.some(file => {
-      // Simplificado: verificar se o arquivo corresponde ao glob pattern
-      // Ex: "app/**/page.tsx" deve corresponder a "app/dashboard/page.tsx"
-      const regexPattern = glob
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\//g, '\\/');
-      const regex = new RegExp(`^${regexPattern}$`);
-      return regex.test(file);
-    });
+    const regexPattern = glob
+      .replace(/\*\*/g, '.*')
+      .replace(/\*/g, '[^/]*')
+      .replace(/\//g, '\\/');
+    const regex = new RegExp(`^${regexPattern}$`);
+    return files.some(file => regex.test(file));
   });
 }
 
@@ -478,22 +586,6 @@ export function getRelatedFiles(decisionOrPattern: string, type: "decision" | "p
   return results.map(r => r.file);
 }
 
-export function findContradictions(specId: string): Array<{ decision1: string; decision2: string; createdAt: string }> {
-  const db = getDb();
-
-  return db.query(`
-    SELECT
-      d1.title as decision1,
-      d2.title as decision2,
-      kg.created_at as createdAt
-    FROM knowledge_graph kg
-    JOIN decisions d1 ON kg.source_id = d1.id
-    JOIN decisions d2 ON kg.target_id = d2.id
-    WHERE kg.relation = 'contradicts'
-    AND kg.spec_id = ?
-  `).all(specId) as any[];
-}
-
 // ═══════════════════════════════════════════════════════════════
 // v8.0: Reasoning Log Helpers
 // ═══════════════════════════════════════════════════════════════
@@ -539,68 +631,6 @@ export function getRecentReasoning(specId: string, limit: number = 20): any[] {
   `).all(specId, limit) as any[];
 }
 
-// ═══════════════════════════════════════════════════════════════
-// v8.0: Session Summary Helpers
-// ═══════════════════════════════════════════════════════════════
-
-export interface SessionSummaryData {
-  startTime: string;
-  endTime: string;
-  summary: string;
-  decisions?: string[];
-  blockers?: string[];
-  nextSteps?: string[];
-  tasksCompleted?: number;
-  filesCreated?: number;
-  filesModified?: number;
-}
-
-export function addSessionSummary(specId: string, data: SessionSummaryData): void {
-  const db = getDb();
-  const now = new Date().toISOString();
-
-  db.run(
-    `INSERT INTO session_summaries (spec_id, start_time, end_time, summary, decisions, blockers, next_steps, tasks_completed, files_created, files_modified, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [
-      specId,
-      data.startTime,
-      data.endTime,
-      data.summary,
-      data.decisions ? JSON.stringify(data.decisions) : null,
-      data.blockers ? JSON.stringify(data.blockers) : null,
-      data.nextSteps ? JSON.stringify(data.nextSteps) : null,
-      data.tasksCompleted || 0,
-      data.filesCreated || 0,
-      data.filesModified || 0,
-      now,
-    ]
-  );
-}
-
-export function getLastSessionSummary(specId: string): any {
-  const db = getDb();
-
-  return db.query(`
-    SELECT * FROM session_summaries
-    WHERE spec_id = ?
-    ORDER BY created_at DESC
-    LIMIT 1
-  `).get(specId);
-}
-
-// v8.3: Retorna ultimas N sessoes para contexto composto
-export function getSessionSummaries(specId: string, limit: number = 5): any[] {
-  const db = getDb();
-
-  return db.query(`
-    SELECT * FROM session_summaries
-    WHERE spec_id = ?
-    ORDER BY created_at DESC
-    LIMIT ?
-  `).all(specId, limit) as any[];
-}
-
 // 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 {