@codexa/cli 9.0.7 → 9.0.8

package/context/domains.test.ts

@@ -0,0 +1,278 @@
+import { describe, it, expect } from "bun:test";
+import {
+  getAgentDomain,
+  domainToScope,
+  adjustSectionPriorities,
+  AGENT_DOMAIN,
+  DOMAIN_PROFILES,
+} from "./domains";
+import type { ContextSection } from "./assembly";
+
+function makeSections(): ContextSection[] {
+  return [
+    { name: "STANDARDS", content: "...", priority: 1 },
+    { name: "ALERTAS", content: "...", priority: 2 },
+    { name: "ARQUITETURA", content: "...", priority: 3 },
+    { name: "DECISOES", content: "...", priority: 4 },
+    { name: "CONTEXTO DE TASKS ANTERIORES", content: "...", priority: 5 },
+    { name: "GRAPH", content: "...", priority: 6 },
+    { name: "PRODUTO", content: "...", priority: 7 },
+    { name: "DISCOVERIES", content: "...", priority: 8 },
+    { name: "UTILITIES", content: "...", priority: 8 },
+    { name: "PATTERNS", content: "...", priority: 9 },
+    { name: "HINTS", content: "...", priority: 10 },
+    { name: "STACK", content: "...", priority: 11 },
+  ];
+}
+
+// ── getAgentDomain ───────────────────────────────────────────
+
+describe("getAgentDomain", () => {
+  it("maps backend agents correctly", () => {
+    expect(getAgentDomain("backend-javascript")).toBe("backend");
+    expect(getAgentDomain("expert-csharp-developer")).toBe("backend");
+    expect(getAgentDomain("golang-pro")).toBe("backend");
+  });
+
+  it("maps frontend agents correctly", () => {
+    expect(getAgentDomain("expert-nextjs-developer")).toBe("frontend");
+    expect(getAgentDomain("frontend-flutter")).toBe("frontend");
+  });
+
+  it("maps database agent correctly", () => {
+    expect(getAgentDomain("expert-postgres-developer")).toBe("database");
+  });
+
+  it("maps testing agent correctly", () => {
+    expect(getAgentDomain("testing-unit")).toBe("testing");
+  });
+
+  it("maps review agent correctly", () => {
+    expect(getAgentDomain("expert-code-reviewer")).toBe("review");
+  });
+
+  it("maps security agent correctly", () => {
+    expect(getAgentDomain("security-specialist")).toBe("security");
+  });
+
+  it("maps explore agent correctly", () => {
+    expect(getAgentDomain("deep-explore")).toBe("explore");
+  });
+
+  it("maps architecture agent correctly", () => {
+    expect(getAgentDomain("architect")).toBe("architecture");
+  });
+
+  it("returns null for unknown agents", () => {
+    expect(getAgentDomain("unknown-agent")).toBeNull();
+    expect(getAgentDomain("general-purpose")).toBeNull();
+  });
+
+  it("returns null for null/undefined/empty input", () => {
+    expect(getAgentDomain(null)).toBeNull();
+    expect(getAgentDomain(undefined)).toBeNull();
+    expect(getAgentDomain("")).toBeNull();
+  });
+});
+
+// ── domainToScope ────────────────────────────────────────────
+
+describe("domainToScope", () => {
+  it("maps code domains to their scope names", () => {
+    expect(domainToScope("backend")).toBe("backend");
+    expect(domainToScope("frontend")).toBe("frontend");
+    expect(domainToScope("database")).toBe("database");
+    expect(domainToScope("testing")).toBe("testing");
+  });
+
+  it("maps cross-cutting domains to 'all'", () => {
+    expect(domainToScope("review")).toBe("all");
+    expect(domainToScope("security")).toBe("all");
+    expect(domainToScope("explore")).toBe("all");
+    expect(domainToScope("architecture")).toBe("all");
+  });
+
+  it("returns 'all' for null domain", () => {
+    expect(domainToScope(null)).toBe("all");
+  });
+
+  // Regression: verifies the split("-")[0] bug is fixed
+  it("expert-postgres-developer resolves to 'database' scope (not 'expert')", () => {
+    const domain = getAgentDomain("expert-postgres-developer");
+    expect(domainToScope(domain)).toBe("database");
+  });
+
+  it("expert-nextjs-developer resolves to 'frontend' scope (not 'expert')", () => {
+    const domain = getAgentDomain("expert-nextjs-developer");
+    expect(domainToScope(domain)).toBe("frontend");
+  });
+
+  it("golang-pro resolves to 'backend' scope (not 'golang')", () => {
+    const domain = getAgentDomain("golang-pro");
+    expect(domainToScope(domain)).toBe("backend");
+  });
+});
+
+// ── adjustSectionPriorities ──────────────────────────────────
+
+describe("adjustSectionPriorities", () => {
+  it("null domain passes all sections through unchanged", () => {
+    const sections = makeSections();
+    const result = adjustSectionPriorities(sections, null);
+    expect(result).toHaveLength(12);
+    expect(result).toEqual(sections);
+  });
+
+  it("explore domain excludes relevance-0 sections", () => {
+    const result = adjustSectionPriorities(makeSections(), "explore");
+    const names = result.map(s => s.name);
+
+    // explore profile: 7 sections have relevance 0
+    expect(names).not.toContain("STANDARDS");
+    expect(names).not.toContain("CONTEXTO DE TASKS ANTERIORES");
+    expect(names).not.toContain("GRAPH");
+    expect(names).not.toContain("PRODUTO");
+    expect(names).not.toContain("UTILITIES");
+    expect(names).not.toContain("PATTERNS");
+    expect(names).not.toContain("HINTS");
+
+    // Should contain the 5 non-zero sections
+    expect(names).toContain("ALERTAS");
+    expect(names).toContain("ARQUITETURA");
+    expect(names).toContain("DECISOES");
+    expect(names).toContain("DISCOVERIES");
+    expect(names).toContain("STACK");
+    expect(result).toHaveLength(5);
+  });
+
+  it("essential sections (relevance=3) get priority boosted by -2", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: DECISOES=3 (base 4 + offset -2 = 2)
+    const decisoes = result.find(s => s.name === "DECISOES");
+    expect(decisoes?.priority).toBe(2);
+
+    // backend: UTILITIES=3 (base 8 + offset -2 = 6)
+    const utilities = result.find(s => s.name === "UTILITIES");
+    expect(utilities?.priority).toBe(6);
+  });
+
+  it("priority floor is 1 (never goes below)", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: STANDARDS=3 (base 1 + offset -2 = -1 → floor 1)
+    const standards = result.find(s => s.name === "STANDARDS");
+    expect(standards?.priority).toBe(1);
+
+    // backend: ALERTAS=3 (base 2 + offset -2 = 0 → floor 1)
+    const alertas = result.find(s => s.name === "ALERTAS");
+    expect(alertas?.priority).toBe(1);
+  });
+
+  it("nice-to-have sections (relevance=1) get deprioritized by +4", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: PRODUTO=1 (base 7 + offset +4 = 11)
+    const produto = result.find(s => s.name === "PRODUTO");
+    expect(produto?.priority).toBe(11);
+  });
+
+  it("useful sections (relevance=2) keep base priority", () => {
+    const result = adjustSectionPriorities(makeSections(), "backend");
+
+    // backend: ARQUITETURA=2 (base 3 + offset 0 = 3)
+    const arq = result.find(s => s.name === "ARQUITETURA");
+    expect(arq?.priority).toBe(3);
+  });
+
+  it("testing domain excludes only PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "testing");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+    expect(result).toHaveLength(11);
+  });
+
+  it("testing domain boosts CONTEXTO DE TASKS ANTERIORES (relevance=3)", () => {
+    const result = adjustSectionPriorities(makeSections(), "testing");
+    const ctx = result.find(s => s.name === "CONTEXTO DE TASKS ANTERIORES");
+    // base 5 + offset -2 = 3
+    expect(ctx?.priority).toBe(3);
+  });
+
+  it("database domain excludes PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "database");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+  });
+
+  it("frontend domain keeps PRODUTO with boosted priority", () => {
+    const result = adjustSectionPriorities(makeSections(), "frontend");
+    const produto = result.find(s => s.name === "PRODUTO");
+    // frontend: PRODUTO=3 (base 7 + offset -2 = 5)
+    expect(produto?.priority).toBe(5);
+  });
+
+  it("security domain excludes PRODUTO (relevance=0)", () => {
+    const result = adjustSectionPriorities(makeSections(), "security");
+    const names = result.map(s => s.name);
+    expect(names).not.toContain("PRODUTO");
+    expect(result).toHaveLength(11);
+  });
+
+  it("handles unknown section names gracefully (forward compatibility)", () => {
+    const sections: ContextSection[] = [
+      { name: "FUTURE_SECTION", content: "...", priority: 5 },
+      { name: "STANDARDS", content: "...", priority: 1 },
+    ];
+    const result = adjustSectionPriorities(sections, "backend");
+    expect(result).toHaveLength(2);
+    const future = result.find(s => s.name === "FUTURE_SECTION");
+    expect(future?.priority).toBe(5); // unchanged
+  });
+});
+
+// ── DOMAIN_PROFILES completeness ─────────────────────────────
+
+describe("DOMAIN_PROFILES completeness", () => {
+  const allSectionNames = [
+    "STANDARDS", "ALERTAS", "ARQUITETURA", "DECISOES",
+    "CONTEXTO DE TASKS ANTERIORES", "GRAPH", "PRODUTO",
+    "DISCOVERIES", "UTILITIES", "PATTERNS", "HINTS", "STACK",
+  ];
+
+  it("every domain profile covers all 12 sections", () => {
+    for (const [domain, profile] of Object.entries(DOMAIN_PROFILES)) {
+      for (const section of allSectionNames) {
+        expect(profile[section as keyof typeof profile]).toBeDefined();
+      }
+    }
+  });
+
+  it("all relevance values are 0, 1, 2, or 3", () => {
+    for (const [domain, profile] of Object.entries(DOMAIN_PROFILES)) {
+      for (const [section, relevance] of Object.entries(profile)) {
+        expect([0, 1, 2, 3]).toContain(relevance);
+      }
+    }
+  });
+});
+
+// ── AGENT_DOMAIN completeness ────────────────────────────────
+
+describe("AGENT_DOMAIN completeness", () => {
+  it("maps all 11 known agents", () => {
+    const knownAgents = [
+      "backend-javascript", "expert-csharp-developer", "golang-pro",
+      "expert-nextjs-developer", "frontend-flutter",
+      "expert-postgres-developer",
+      "testing-unit",
+      "expert-code-reviewer",
+      "security-specialist",
+      "deep-explore",
+      "architect",
+    ];
+    for (const agent of knownAgents) {
+      expect(AGENT_DOMAIN[agent]).toBeDefined();
+    }
+  });
+});

package/context/domains.ts

@@ -0,0 +1,156 @@
+// ═══════════════════════════════════════════════════════════════
+// DOMAIN-BASED CONTEXT PRIORITY (v9.4)
+// Replaces binary AGENT_SECTIONS with relevance-based filtering.
+// ═══════════════════════════════════════════════════════════════
+
+import type { ContextSection } from "./assembly";
+
+export type AgentDomain =
+  | "backend"
+  | "frontend"
+  | "database"
+  | "testing"
+  | "review"
+  | "security"
+  | "explore"
+  | "architecture";
+
+export type Relevance = 0 | 1 | 2 | 3;
+
+export type SectionName =
+  | "STANDARDS"
+  | "ALERTAS"
+  | "ARQUITETURA"
+  | "DECISOES"
+  | "CONTEXTO DE TASKS ANTERIORES"
+  | "GRAPH"
+  | "PRODUTO"
+  | "DISCOVERIES"
+  | "UTILITIES"
+  | "PATTERNS"
+  | "HINTS"
+  | "STACK";
+
+export type DomainProfile = Record<SectionName, Relevance>;
+
+// ── Agent → Domain mapping ───────────────────────────────────
+
+export const AGENT_DOMAIN: Record<string, AgentDomain> = {
+  "backend-javascript":       "backend",
+  "expert-csharp-developer":  "backend",
+  "golang-pro":               "backend",
+  "expert-nextjs-developer":  "frontend",
+  "frontend-flutter":         "frontend",
+  "expert-postgres-developer": "database",
+  "testing-unit":             "testing",
+  "expert-code-reviewer":     "review",
+  "security-specialist":      "security",
+  "deep-explore":             "explore",
+  "architect":                "architecture",
+};
+
+// ── Domain → Section relevance profiles ──────────────────────
+//
+// 3 = essential  (priority offset -2, survives truncation)
+// 2 = useful     (priority offset  0, base priority kept)
+// 1 = nice-to-have (priority offset +4, dropped first on truncation)
+// 0 = noise      (excluded entirely)
+
+export const DOMAIN_PROFILES: Record<AgentDomain, DomainProfile> = {
+  backend: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 2, "STACK": 2,
+  },
+  frontend: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 2,
+  },
+  database: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 2, "STACK": 3,
+  },
+  testing: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 1, "DECISOES": 2,
+    "CONTEXTO DE TASKS ANTERIORES": 3, "GRAPH": 1, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 3, "HINTS": 2, "STACK": 1,
+  },
+  review: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 1,
+    "DISCOVERIES": 2, "UTILITIES": 3, "PATTERNS": 2, "HINTS": 3, "STACK": 2,
+  },
+  security: {
+    "STANDARDS": 3, "ALERTAS": 3, "ARQUITETURA": 2, "DECISOES": 2,
+    "CONTEXTO DE TASKS ANTERIORES": 1, "GRAPH": 1, "PRODUTO": 0,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 1, "HINTS": 2, "STACK": 3,
+  },
+  explore: {
+    "STANDARDS": 0, "ALERTAS": 1, "ARQUITETURA": 3, "DECISOES": 1,
+    "CONTEXTO DE TASKS ANTERIORES": 0, "GRAPH": 0, "PRODUTO": 0,
+    "DISCOVERIES": 1, "UTILITIES": 0, "PATTERNS": 0, "HINTS": 0, "STACK": 3,
+  },
+  architecture: {
+    "STANDARDS": 2, "ALERTAS": 2, "ARQUITETURA": 3, "DECISOES": 3,
+    "CONTEXTO DE TASKS ANTERIORES": 2, "GRAPH": 2, "PRODUTO": 3,
+    "DISCOVERIES": 2, "UTILITIES": 1, "PATTERNS": 2, "HINTS": 1, "STACK": 3,
+  },
+};
+
+// ── Priority offset per relevance level ──────────────────────
+
+const RELEVANCE_OFFSET: Record<Relevance, number> = {
+  3: -2,  // essential: boost
+  2: 0,   // useful: keep as-is
+  1: 4,   // nice-to-have: deprioritize
+  0: 0,   // noise: excluded before this applies
+};
+
+// ── Functions ────────────────────────────────────────────────
+
+export function getAgentDomain(agentName: string | null | undefined): AgentDomain | null {
+  if (!agentName) return null;
+  return AGENT_DOMAIN[agentName] ?? null;
+}
+
+export function domainToScope(domain: AgentDomain | null): string {
+  if (!domain) return "all";
+
+  const scopeMap: Record<AgentDomain, string> = {
+    backend: "backend",
+    frontend: "frontend",
+    database: "database",
+    testing: "testing",
+    review: "all",
+    security: "all",
+    explore: "all",
+    architecture: "all",
+  };
+
+  return scopeMap[domain];
+}
+
+export function adjustSectionPriorities(
+  sections: ContextSection[],
+  domain: AgentDomain | null,
+): ContextSection[] {
+  if (!domain) return sections;
+
+  const profile = DOMAIN_PROFILES[domain];
+
+  return sections
+    .filter(s => {
+      const relevance = profile[s.name as SectionName];
+      // Unknown section names pass through (forward compatibility)
+      return relevance === undefined || relevance > 0;
+    })
+    .map(s => {
+      const relevance = profile[s.name as SectionName];
+      if (relevance === undefined) return s;
+
+      const offset = RELEVANCE_OFFSET[relevance];
+      return { ...s, priority: Math.max(1, s.priority + offset) };
+    });
+}

package/context/generator.ts

@@ -2,7 +2,8 @@ import { getDb } from "../db/connection";
 import { initSchema, getPatternsForFiles, getRelatedDecisions, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { getKnowledgeForTask } from "../commands/knowledge";
 import type { ContextSection, ContextData } from "./assembly";
-import { assembleSections, AGENT_SECTIONS } from "./assembly";
+import { assembleSections } from "./assembly";
+import { getAgentDomain, adjustSectionPriorities, domainToScope } from "./domains";
 import { filterRelevantDecisions, filterRelevantStandards } from "./scoring";
 import {
     buildProductSection,
@@ -33,7 +34,7 @@ export function getMinimalContextForSubagent(taskId: number): string {
     const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(task.spec_id) as any;
 
     const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
+    const domain = domainToScope(getAgentDomain(task.agent));
 
     // 1. Standards REQUIRED apenas (nao recommended)
     const requiredStandards = db.query(
@@ -42,11 +43,12 @@ export function getMinimalContextForSubagent(taskId: number): string {
          LIMIT 10`
     ).all(domain) as any[];
 
-    // 2. Blockers CRITICAL apenas
+    // 2. Blockers CRITICAL (spec atual + cross-feature)
     const criticalBlockers = db.query(
-        `SELECT content FROM knowledge
-         WHERE spec_id = ? AND severity = 'critical'
-         ORDER BY created_at DESC LIMIT 5`
+        `SELECT DISTINCT content FROM knowledge
+         WHERE severity = 'critical'
+         ORDER BY CASE WHEN spec_id = ? THEN 0 ELSE 1 END, created_at DESC
+         LIMIT 5`
     ).all(task.spec_id) as any[];
 
     // 3. Decisoes da task anterior (dependency direta)
@@ -124,7 +126,7 @@ function fetchContextData(taskId: number): ContextData | null {
 
     // Arquivos da task para filtrar contexto relevante
     const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
+    const domain = domainToScope(getAgentDomain(task.agent));
 
     // Decisoes relevantes (max 8, priorizando as que mencionam arquivos da task)
     const allDecisions = db
@@ -262,12 +264,9 @@ export function getContextForSubagent(taskId: number): string {
         buildHintsSection(data),
     ].filter((s): s is ContextSection => s !== null);
 
-    // v9.3: Filtrar secoes por tipo de agente
-    const agentType = data.task.agent || "";
-    const allowedSections = AGENT_SECTIONS[agentType];
-    const sections = allowedSections
-        ? allSections.filter(s => allowedSections.includes(s.name))
-        : allSections;
+    // v9.4: Domain-based priority adjustment (replaces binary AGENT_SECTIONS)
+    const agentDomain = getAgentDomain(data.task.agent);
+    const sections = adjustSectionPriorities(allSections, agentDomain);
 
     return assembleSections(header, sections);
 }

package/context/index.ts

@@ -1,6 +1,8 @@
 // Re-exports for backward compatibility
 export { getContextForSubagent, getMinimalContextForSubagent } from "./generator";
-export { assembleSections, MAX_CONTEXT_SIZE, AGENT_SECTIONS } from "./assembly";
+export { assembleSections, MAX_CONTEXT_SIZE } from "./assembly";
+export { AGENT_DOMAIN, DOMAIN_PROFILES, getAgentDomain, adjustSectionPriorities, domainToScope } from "./domains";
+export type { AgentDomain, Relevance, SectionName, DomainProfile } from "./domains";
 export type { ContextSection, ContextData } from "./assembly";
 export { filterRelevantDecisions, filterRelevantStandards } from "./scoring";
 export {

package/context/sections.ts

@@ -1,5 +1,6 @@
 import { getUtilitiesForContext, getAgentHints } from "../db/schema";
 import type { ContextSection, ContextData } from "./assembly";
+import { getAgentDomain, domainToScope } from "./domains";
 
 // ── Section Builders ──────────────────────────────────────────
 
@@ -162,7 +163,7 @@ export function buildUtilitiesSection(data: ContextData): ContextSection | null
             return parts.slice(0, -1).join("/");
         }).filter(Boolean))];
 
-        const agentScope = data.task.agent?.split("-")[0] || undefined;
+        const agentScope = domainToScope(getAgentDomain(data.task.agent)) || undefined;
         let relevantUtilities = getUtilitiesForContext(taskDirs, undefined, 15);
 
         if (relevantUtilities.length < 5 && agentScope) {

package/db/schema.ts

@@ -237,7 +237,6 @@ export function initSchema(): void {
       relation TEXT NOT NULL,     -- uses, implements, depends_on, modifies, contradicts, extracted_from
 
       -- Metadados
-      strength REAL DEFAULT 1.0,  -- 0-1, peso da relacao
       metadata TEXT,              -- JSON com informacoes adicionais
 
       created_at TEXT DEFAULT CURRENT_TIMESTAMP
@@ -459,6 +458,28 @@ const MIGRATIONS: Migration[] = [
       }
     },
   },
+  {
+    version: "9.5.0",
+    description: "Adicionar superseded_by na tabela decisions",
+    up: (db) => {
+      db.exec(`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'`);
+    },
+  },
+  {
+    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`);
+    },
+  },
 ];
 
 export function runMigrations(): void {
@@ -521,6 +542,22 @@ export function claimTask(taskId: number): boolean {
   return result.changes > 0;
 }
 
+const STUCK_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutos
+
+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[];
+
+  const now = Date.now();
+  return running.filter((task: any) => {
+    if (!task.started_at) return true;
+    const elapsed = now - new Date(task.started_at).getTime();
+    return elapsed > STUCK_THRESHOLD_MS;
+  });
+}
+
 export function getPatternsByScope(scope: string): any[] {
   const db = getDb();
   return db.query(
@@ -582,7 +619,6 @@ export interface GraphRelation {
   targetType: string;
   targetId: string;
   relation: string;
-  strength?: number;
   metadata?: Record<string, any>;
 }
 
@@ -591,8 +627,8 @@ export function addGraphRelation(specId: string | null, relation: GraphRelation)
   const now = new Date().toISOString();
 
   db.run(
-    `INSERT INTO knowledge_graph (spec_id, source_type, source_id, target_type, target_id, relation, strength, metadata, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    `INSERT INTO knowledge_graph (spec_id, source_type, source_id, target_type, target_id, relation, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
     [
       specId,
       relation.sourceType,
@@ -600,7 +636,6 @@ export function addGraphRelation(specId: string | null, relation: GraphRelation)
       relation.targetType,
       relation.targetId,
       relation.relation,
-      relation.strength || 1.0,
       relation.metadata ? JSON.stringify(relation.metadata) : null,
       now,
     ]

package/db/test-helpers.ts

@@ -0,0 +1,33 @@
+import { getDb } from "./connection";
+
+/**
+ * Limpa todas as tabelas do DB respeitando ordem de FK constraints.
+ * Usa PRAGMA foreign_keys = OFF como safety net.
+ *
+ * Uso: beforeEach(() => { initSchema(); cleanDb(); });
+ */
+export function cleanDb() {
+  const db = getDb();
+  db.run("PRAGMA foreign_keys = OFF");
+  try {
+    // Folhas (sem dependentes) primeiro
+    db.run("DELETE FROM knowledge_acknowledgments");
+    db.run("DELETE FROM agent_performance");
+    db.run("DELETE FROM reasoning_log");
+    db.run("DELETE FROM knowledge_graph");
+    db.run("DELETE FROM gate_bypasses");
+    db.run("DELETE FROM snapshots");
+    db.run("DELETE FROM review");
+    db.run("DELETE FROM project_utilities");
+    db.run("DELETE FROM artifacts");
+    db.run("DELETE FROM decisions");
+    // Dependentes de knowledge (antes de knowledge)
+    db.run("DELETE FROM knowledge");
+    // Dependentes de tasks/specs
+    db.run("DELETE FROM tasks");
+    db.run("DELETE FROM context");
+    db.run("DELETE FROM specs");
+  } finally {
+    db.run("PRAGMA foreign_keys = ON");
+  }
+}