@codexa/cli 9.0.7 → 9.0.8

package/commands/product.ts

@@ -27,53 +27,6 @@ interface ProductFeature {
   priority: "high" | "medium" | "low";
 }
 
-// ═══════════════════════════════════════════════════════════════
-// PRODUCT GUIDE - Inicia o processo guiado
-// ═══════════════════════════════════════════════════════════════
-
-export function productGuide(json: boolean = false): void {
-  initSchema();
-  const db = getDb();
-
-  // Verificar se ja existe
-  const existing = db.query("SELECT * FROM product_context WHERE id = 'default'").get();
-  if (existing) {
-    console.log("\nContexto de produto ja definido.");
-    console.log("Use: product show para ver detalhes");
-    console.log("Ou: product reset para refazer\n");
-    return;
-  }
-
-  if (json) {
-    console.log(JSON.stringify({ status: "ready_for_guide", message: "Use AskUserQuestion para guiar o usuario" }, null, 2));
-    return;
-  }
-
-  console.log("\n" + "═".repeat(60));
-  console.log("PRODUCT DISCOVERY - Modo Guiado");
-  console.log("═".repeat(60));
-  console.log(`
-Este modo vai ajudar a definir o contexto do produto atraves de perguntas.
-
-O agente vai usar AskUserQuestion para coletar:
-1. Nome do produto
-2. Problema que resolve
-3. Solucao proposta
-4. Usuarios alvo
-5. Proposta de valor
-6. Metricas de sucesso
-7. O que esta fora do escopo
-8. Restricoes conhecidas
-
-Apos coletar as respostas, use:
-  product set --name "..." --problem "..." ...
-
-Para confirmar e salvar:
-  product confirm
-`);
-  console.log("─".repeat(60) + "\n");
-}
-
 // ═══════════════════════════════════════════════════════════════
 // PRODUCT IMPORT - Importa PRD existente
 // ═══════════════════════════════════════════════════════════════
@@ -142,6 +95,8 @@ export function productSet(options: {
   successMetrics?: string;
   outOfScope?: string;
   constraints?: string;
+  goal?: string;
+  feature?: string;
 }): void {
   initSchema();
   const db = getDb();
@@ -208,6 +163,42 @@ export function productSet(options: {
     );
   }
 
+  // Adicionar objetivo (formato: "category:text:priority")
+  if (options.goal) {
+    const parts = options.goal.split(":");
+    const category = parts[0] || "geral";
+    const goal = parts[1] || options.goal;
+    const priority = parts[2] || "medium";
+
+    db.run(
+      `INSERT INTO product_goals (product_id, category, goal, priority, created_at)
+       VALUES ('pending', ?, ?, ?, ?)`,
+      [category, goal, priority, now]
+    );
+
+    const count = db.query("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'pending'").get() as any;
+    console.log(`\nObjetivo adicionado (${count.c} total)`);
+    console.log(`  [${category}] ${goal} (${priority})`);
+  }
+
+  // Adicionar feature (formato: "name:description:priority")
+  if (options.feature) {
+    const parts = options.feature.split(":");
+    const name = parts[0];
+    const description = parts[1] || "";
+    const priority = parts[2] || "medium";
+
+    db.run(
+      `INSERT INTO product_features (product_id, name, description, priority, created_at)
+       VALUES ('pending', ?, ?, ?, ?)`,
+      [name, description, priority, now]
+    );
+
+    const count = db.query("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'pending'").get() as any;
+    console.log(`\nFeature adicionada (${count.c} total)`);
+    console.log(`  ${name} (${priority})`);
+  }
+
   // Mostrar estado atual
   const current = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
 
@@ -221,60 +212,6 @@ export function productSet(options: {
   console.log("\nPara confirmar: product confirm\n");
 }
 
-// ═══════════════════════════════════════════════════════════════
-// PRODUCT GOAL ADD - Adiciona objetivo
-// ═══════════════════════════════════════════════════════════════
-
-export function productGoalAdd(options: {
-  category: string;
-  goal: string;
-  priority?: string;
-}): void {
-  initSchema();
-  const db = getDb();
-
-  const now = new Date().toISOString();
-  const priority = options.priority || "medium";
-
-  db.run(
-    `INSERT INTO product_goals (product_id, category, goal, priority, created_at)
-     VALUES ('pending', ?, ?, ?, ?)`,
-    [options.category, options.goal, priority, now]
-  );
-
-  const count = db.query("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'pending'").get() as any;
-
-  console.log(`\nObjetivo adicionado (${count.c} total)`);
-  console.log(`  [${options.category}] ${options.goal} (${priority})\n`);
-}
-
-// ═══════════════════════════════════════════════════════════════
-// PRODUCT FEATURE ADD - Adiciona feature core
-// ═══════════════════════════════════════════════════════════════
-
-export function productFeatureAdd(options: {
-  name: string;
-  description?: string;
-  priority?: string;
-}): void {
-  initSchema();
-  const db = getDb();
-
-  const now = new Date().toISOString();
-  const priority = options.priority || "medium";
-
-  db.run(
-    `INSERT INTO product_features (product_id, name, description, priority, created_at)
-     VALUES ('pending', ?, ?, ?, ?)`,
-    [options.name, options.description || "", priority, now]
-  );
-
-  const count = db.query("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'pending'").get() as any;
-
-  console.log(`\nFeature adicionada (${count.c} total)`);
-  console.log(`  ${options.name} (${priority})\n`);
-}
-
 // ═══════════════════════════════════════════════════════════════
 // PRODUCT CONFIRM - Confirma e salva
 // ═══════════════════════════════════════════════════════════════
@@ -285,7 +222,7 @@ export function productConfirm(): void {
 
   const pending = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
   if (!pending) {
-    throw new CodexaError("Nenhum contexto de produto pendente.\nExecute: product guide ou product import primeiro");
+    throw new CodexaError("Nenhum contexto de produto pendente.\nExecute: product import primeiro");
   }
 
   // Validar campos obrigatorios
@@ -353,7 +290,7 @@ export function productShow(options: { json?: boolean; pending?: boolean } = {})
     if (options.pending) {
       throw new CodexaError("Nenhum contexto pendente.");
     } else {
-      throw new CodexaError("Contexto de produto nao definido.\nExecute: product guide ou product import");
+      throw new CodexaError("Contexto de produto nao definido.\nExecute: product import para definir");
     }
   }
 
@@ -481,7 +418,7 @@ export function productReset(): void {
   db.run("DELETE FROM product_context");
 
   console.log("\nContexto de produto resetado.");
-  console.log("Execute: product guide ou product import para refazer\n");
+  console.log("Execute: product import para refazer\n");
 }
 
 // ═══════════════════════════════════════════════════════════════

package/commands/spec-resolver.test.ts

@@ -2,22 +2,11 @@ import { describe, it, expect, beforeEach } from "bun:test";
 import { resolveSpec, getAllActiveSpecs } from "./spec-resolver";
 import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
+import { cleanDb } from "../db/test-helpers";
 
 beforeEach(() => {
   initSchema();
-  const db = getDb();
-  // Limpar em ordem que respeita foreign keys
-  db.run("DELETE FROM reasoning_log");
-  db.run("DELETE FROM knowledge_graph");
-  db.run("DELETE FROM knowledge");
-  db.run("DELETE FROM gate_bypasses");
-  db.run("DELETE FROM snapshots");
-  db.run("DELETE FROM review");
-  db.run("DELETE FROM artifacts");
-  db.run("DELETE FROM decisions");
-  db.run("DELETE FROM tasks");
-  db.run("DELETE FROM context");
-  db.run("DELETE FROM specs");
+  cleanDb();
 });
 
 function createSpec(id: string, name: string, phase: string, createdAt?: string) {

package/commands/standards.ts

@@ -48,6 +48,9 @@ export function standardsList(options: { category?: string; scope?: string; json
 
     const enforcement = std.enforcement === "required" ? "[REQ]" : "[REC]";
     console.log(`  #${std.id} ${enforcement} (${std.scope}) ${std.rule}`);
+    if (std.semantic_query) {
+      console.log(`       Semantic: "${std.semantic_query}" (expect: ${std.expect || "no_match"})`);
+    }
   }
 
   console.log("\n" + "─".repeat(60));
@@ -61,6 +64,8 @@ export function standardsAdd(options: {
   examples?: string;
   antiExamples?: string;
   enforcement?: string;
+  semanticQuery?: string;
+  expect?: string;
 }): void {
   initSchema();
   const db = getDb();
@@ -82,6 +87,12 @@ export function standardsAdd(options: {
     throw new ValidationError(`Enforcement invalido: ${enforcement}\nValidos: ${validEnforcement.join(", ")}`);
   }
 
+  const expectVal = options.expect || "no_match";
+  const validExpects = ["no_match", "must_match"];
+  if (!validExpects.includes(expectVal)) {
+    throw new ValidationError(`Expect invalido: ${expectVal}\nValidos: ${validExpects.join(", ")}`);
+  }
+
   let examples = null;
   let antiExamples = null;
 
@@ -94,9 +105,9 @@ export function standardsAdd(options: {
   }
 
   const result = db.run(
-    `INSERT INTO standards (category, scope, rule, examples, anti_examples, enforcement, source, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, 'user', datetime('now'))`,
-    [options.category, options.scope, options.rule, examples, antiExamples, enforcement]
+    `INSERT INTO standards (category, scope, rule, examples, anti_examples, enforcement, semantic_query, expect, source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'user', datetime('now'))`,
+    [options.category, options.scope, options.rule, examples, antiExamples, enforcement, options.semanticQuery || null, expectVal]
   );
 
   // Regenerar markdown
@@ -107,6 +118,9 @@ export function standardsAdd(options: {
   console.log(`  Escopo: ${options.scope}`);
   console.log(`  Regra: ${options.rule}`);
   console.log(`  Enforcement: ${enforcement}`);
+  if (options.semanticQuery) {
+    console.log(`  Semantic Query: "${options.semanticQuery}" (expect: ${expectVal})`);
+  }
   console.log("\nArquivo atualizado: .codexa/standards.md\n");
 }
 
@@ -117,6 +131,8 @@ export function standardsEdit(
     examples?: string;
     antiExamples?: string;
     enforcement?: string;
+    semanticQuery?: string;
+    expect?: string;
   }
 ): void {
   initSchema();
@@ -152,6 +168,20 @@ export function standardsEdit(
     params.push(options.enforcement);
   }
 
+  if (options.semanticQuery !== undefined) {
+    updates.push("semantic_query = ?");
+    params.push(options.semanticQuery || null);
+  }
+
+  if (options.expect) {
+    const validExpects = ["no_match", "must_match"];
+    if (!validExpects.includes(options.expect)) {
+      throw new ValidationError(`Expect invalido: ${options.expect}\nValidos: ${validExpects.join(", ")}`);
+    }
+    updates.push("expect = ?");
+    params.push(options.expect);
+  }
+
   if (updates.length === 0) {
     throw new ValidationError("Nenhuma alteracao fornecida.");
   }

package/commands/task.ts

@@ -1,5 +1,5 @@
 import { getDb } from "../db/connection";
-import { initSchema, getPatternsForFiles, getPatternsByScope, getRecentReasoning, claimTask, recordAgentPerformance } from "../db/schema";
+import { initSchema, getPatternsForFiles, getPatternsByScope, getRecentReasoning, claimTask, recordAgentPerformance, detectStuckTasks } from "../db/schema";
 import { enforceGate } from "../gates/validator";
 import { parseSubagentReturn, formatValidationErrors } from "../protocol/subagent-protocol";
 import { processSubagentReturn, formatProcessResult } from "../protocol/process-return";
@@ -8,6 +8,7 @@ import { getUnreadKnowledgeForTask } from "./knowledge";
 import { loadTemplate } from "../templates/loader";
 import { TaskStateError, ValidationError, KnowledgeBlockError } from "../errors";
 import { resolveSpec, resolveSpecOrNull } from "./spec-resolver";
+import { getAgentDomain, domainToScope } from "../context/domains";
 
 export function taskNext(json: boolean = false, specId?: string): void {
   initSchema();
@@ -59,7 +60,12 @@ 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}`);
-      console.log("Aguarde as tasks em andamento serem concluidas.\n");
+      const stuck = detectStuckTasks(spec.id);
+      if (stuck.length > 0) {
+        showStuckWarning(stuck);
+      } else {
+        console.log("Aguarde as tasks em andamento serem concluidas.\n");
+      }
     }
     return;
   }
@@ -100,6 +106,17 @@ export function taskNext(json: boolean = false, specId?: string): void {
   console.log(`Use: task start <id> ou task start <id1>,<id2>,...\n`);
 }
 
+function showStuckWarning(stuck: any[]): void {
+  console.log(`\n[!] AVISO: ${stuck.length} task(s) parada(s) ha mais de 30 minutos:`);
+  for (const t of stuck) {
+    const elapsed = t.started_at
+      ? Math.round((Date.now() - new Date(t.started_at).getTime()) / 60000)
+      : "?";
+    console.log(`  #${t.number}: ${t.name} (${elapsed} min)`);
+  }
+  console.log(`  Use: task done <id> --force --force-reason "timeout" para liberar\n`);
+}
+
 export function taskStart(ids: string, json: boolean = false, fullContext: boolean = false, specId?: string): void {
   initSchema();
   enforceGate("task-start");
@@ -171,7 +188,7 @@ export function taskStart(ids: string, json: boolean = false, fullContext: boole
 
       // NOVO v7.4: Buscar implementation patterns relevantes
       const taskFiles = task.files ? JSON.parse(task.files) : [];
-      const agentScope = task.agent?.split("-")[0] || "all"; // frontend-next -> frontend
+      const agentScope = domainToScope(getAgentDomain(task.agent));
 
       // Buscar patterns por escopo do agente E por arquivos esperados
       let relevantPatterns: any[] = [];
@@ -416,7 +433,7 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     const bypassCount = (db.query(
       "SELECT COUNT(*) as c FROM gate_bypasses WHERE task_id = ?"
     ).get(taskId) as any)?.c || 0;
-    const totalGates = 7;
+    const totalGates = 8;
 
     recordAgentPerformance({
       agentType,

package/commands/utils.test.ts

@@ -1,100 +1,38 @@
 /**
- * v9.3: Tests for AGENT_SECTIONS filtering (P3.1 — Context Intelligence)
+ * v9.4: Tests for domain-based context intelligence (replaces AGENT_SECTIONS)
  */
 import { describe, it, expect } from "bun:test";
-import { AGENT_SECTIONS } from "./utils";
-
-describe("AGENT_SECTIONS (P3.1 — Context Intelligence)", () => {
-  it("testing-unit gets focused sections without PRODUTO or STACK", () => {
-    const sections = AGENT_SECTIONS["testing-unit"];
-    expect(sections).toBeDefined();
-    expect(sections).toContain("STANDARDS");
-    expect(sections).toContain("DECISOES");
-    expect(sections).toContain("ALERTAS");
-    expect(sections).toContain("PATTERNS");
-    expect(sections).toContain("UTILITIES");
-    expect(sections).toContain("HINTS");
-    expect(sections).not.toContain("PRODUTO");
-    expect(sections).not.toContain("STACK");
-    expect(sections).not.toContain("ARQUITETURA");
-  });
-
-  it("deep-explore gets minimal sections", () => {
-    const sections = AGENT_SECTIONS["deep-explore"];
-    expect(sections).toBeDefined();
-    expect(sections).toHaveLength(2);
-    expect(sections).toContain("STACK");
-    expect(sections).toContain("ARQUITETURA");
-    expect(sections).not.toContain("HINTS");
+import { AGENT_DOMAIN, getAgentDomain, domainToScope } from "./utils";
+
+describe("Domain exports from utils (backward compatibility)", () => {
+  it("AGENT_DOMAIN is re-exported and maps known agents", () => {
+    expect(AGENT_DOMAIN).toBeDefined();
+    expect(AGENT_DOMAIN["backend-javascript"]).toBe("backend");
+    expect(AGENT_DOMAIN["expert-postgres-developer"]).toBe("database");
+    expect(AGENT_DOMAIN["testing-unit"]).toBe("testing");
   });
 
-  it("security-specialist gets security-relevant sections", () => {
-    const sections = AGENT_SECTIONS["security-specialist"];
-    expect(sections).toBeDefined();
-    expect(sections).toContain("STANDARDS");
-    expect(sections).toContain("DECISOES");
-    expect(sections).toContain("ALERTAS");
-    expect(sections).toContain("STACK");
-    expect(sections).toContain("HINTS");
-    expect(sections).not.toContain("PATTERNS");
-    expect(sections).not.toContain("UTILITIES");
+  it("getAgentDomain is re-exported and works", () => {
+    expect(getAgentDomain("deep-explore")).toBe("explore");
+    expect(getAgentDomain(null)).toBeNull();
   });
 
-  it("expert-code-reviewer gets review-relevant sections", () => {
-    const sections = AGENT_SECTIONS["expert-code-reviewer"];
-    expect(sections).toBeDefined();
-    expect(sections).toContain("STANDARDS");
-    expect(sections).toContain("DECISOES");
-    expect(sections).toContain("ARQUITETURA");
-    expect(sections).toContain("UTILITIES");
-    expect(sections).toContain("ALERTAS");
-    expect(sections).toContain("HINTS");
-    expect(sections).not.toContain("PRODUTO");
+  it("domainToScope is re-exported and works", () => {
+    expect(domainToScope("backend")).toBe("backend");
+    expect(domainToScope(null)).toBe("all");
   });
 
-  it("unknown agent types are not in the map (get all sections)", () => {
-    expect(AGENT_SECTIONS["frontend-next"]).toBeUndefined();
-    expect(AGENT_SECTIONS["database-postgres"]).toBeUndefined();
-    expect(AGENT_SECTIONS["backend-javascript"]).toBeUndefined();
-    expect(AGENT_SECTIONS["general-purpose"]).toBeUndefined();
+  // Regression: old split("-")[0] bug
+  it("expert-csharp-developer maps to 'backend' not 'expert'", () => {
+    const domain = getAgentDomain("expert-csharp-developer");
+    expect(domain).toBe("backend");
+    expect(domainToScope(domain)).toBe("backend");
   });
 
-  it("filtering logic: known agent filters sections", () => {
-    const allSections = [
-      { name: "PRODUTO", content: "...", priority: 7 },
-      { name: "STANDARDS", content: "...", priority: 1 },
-      { name: "ALERTAS", content: "...", priority: 2 },
-      { name: "STACK", content: "...", priority: 11 },
-      { name: "ARQUITETURA", content: "...", priority: 3 },
-      { name: "DECISOES", content: "...", priority: 4 },
-      { name: "PATTERNS", content: "...", priority: 9 },
-    ];
-
-    const agentType = "deep-explore";
-    const allowed = AGENT_SECTIONS[agentType];
-    const filtered = allowed
-      ? allSections.filter(s => allowed.includes(s.name))
-      : allSections;
-
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map(s => s.name)).toContain("STACK");
-    expect(filtered.map(s => s.name)).toContain("ARQUITETURA");
-    expect(filtered.map(s => s.name)).not.toContain("PRODUTO");
-    expect(filtered.map(s => s.name)).not.toContain("STANDARDS");
-  });
-
-  it("filtering logic: unknown agent keeps all sections", () => {
-    const allSections = [
-      { name: "PRODUTO", content: "...", priority: 7 },
-      { name: "STANDARDS", content: "...", priority: 1 },
-    ];
-
-    const agentType = "frontend-next"; // not in AGENT_SECTIONS
-    const allowed = AGENT_SECTIONS[agentType];
-    const filtered = allowed
-      ? allSections.filter(s => allowed.includes(s.name))
-      : allSections;
-
-    expect(filtered).toHaveLength(2); // All kept
+  it("unknown agents return null domain and 'all' scope", () => {
+    expect(getAgentDomain("frontend-next")).toBeNull();
+    expect(getAgentDomain("database-postgres")).toBeNull();
+    expect(getAgentDomain("general-purpose")).toBeNull();
+    expect(domainToScope(getAgentDomain("general-purpose"))).toBe("all");
   });
 });

package/commands/utils.ts

@@ -1,92 +1,16 @@
 import { getDb } from "../db/connection";
-import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
+import { initSchema, getArchitecturalAnalysisForSpec, detectStuckTasks } from "../db/schema";
 import { getKnowledgeForTask } from "./knowledge";
 import { getLibContextsForAgent } from "./research";
 import { resolveSpec, resolveSpecOrNull, getAllActiveSpecs } from "./spec-resolver";
 import { CodexaError } from "../errors";
+import { getAgentDomain, domainToScope } from "../context/domains";
 import pkg from "../package.json";
 
 // Re-export context modules for backward compatibility
 export { getContextForSubagent, getMinimalContextForSubagent } from "../context/generator";
-export { AGENT_SECTIONS, MAX_CONTEXT_SIZE } from "../context/assembly";
-
-export function contextUpdate(options: {
-    approach?: string;
-    pattern?: string;
-    constraint?: string;
-    specId?: string;
-}): void {
-    initSchema();
-    const db = getDb();
-
-    const spec = resolveSpec(options.specId, ["implementing"]);
-
-    const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
-    const now = new Date().toISOString();
-
-    let updated = false;
-
-    if (options.approach) {
-        // Append ao approach existente, não substitui
-        const currentApproach = context?.approach || "";
-        const newApproach = currentApproach
-            ? `${currentApproach}\n- ${options.approach}`
-            : options.approach;
-
-        db.run("UPDATE context SET approach = ?, updated_at = ? WHERE spec_id = ?", [
-            newApproach,
-            now,
-            spec.id,
-        ]);
-        console.log(`\n✓ Approach atualizado`);
-        updated = true;
-    }
-
-    if (options.pattern) {
-        // Adiciona ao array de patterns
-        const currentPatterns = context?.patterns ? JSON.parse(context.patterns) : [];
-        currentPatterns.push({
-            pattern: options.pattern,
-            detected_at: now,
-        });
-
-        db.run("UPDATE context SET patterns = ?, updated_at = ? WHERE spec_id = ?", [
-            JSON.stringify(currentPatterns),
-            now,
-            spec.id,
-        ]);
-        console.log(`✓ Pattern adicionado (total: ${currentPatterns.length})`);
-        updated = true;
-    }
-
-    if (options.constraint) {
-        // Adiciona ao array de constraints
-        const currentConstraints = context?.constraints ? JSON.parse(context.constraints) : [];
-        currentConstraints.push({
-            constraint: options.constraint,
-            added_at: now,
-        });
-
-        db.run("UPDATE context SET constraints = ?, updated_at = ? WHERE spec_id = ?", [
-            JSON.stringify(currentConstraints),
-            now,
-            spec.id,
-        ]);
-        console.log(`✓ Constraint adicionado (total: ${currentConstraints.length})`);
-        updated = true;
-    }
-
-    if (!updated) {
-        console.log("\nNenhuma opcao fornecida.");
-        console.log("Use:");
-        console.log("  --approach 'Nova abordagem descoberta'");
-        console.log("  --pattern 'Padrao identificado no codigo'");
-        console.log("  --constraint 'Nova limitacao encontrada'\n");
-        return;
-    }
-
-    console.log(`\nContexto atualizado para: ${spec.name}\n`);
-}
+export { MAX_CONTEXT_SIZE } from "../context/assembly";
+export { AGENT_DOMAIN, getAgentDomain, domainToScope } from "../context/domains";
 
 export function status(json: boolean = false, specId?: string): void {
     initSchema();
@@ -168,6 +92,20 @@ function showSingleSpecStatus(db: any, spec: any, json: boolean): void {
     console.log(`  Em execucao: ${tasksRunning}`);
     console.log(`  Pendentes: ${tasksPending}`);
 
+    if (tasksRunning > 0) {
+      const stuck = detectStuckTasks(spec.id);
+      if (stuck.length > 0) {
+        console.log(`\n[!] AVISO: ${stuck.length} task(s) parada(s) ha mais de 30 minutos:`);
+        for (const t of stuck) {
+          const elapsed = t.started_at
+            ? Math.round((Date.now() - new Date(t.started_at).getTime()) / 60000)
+            : "?";
+          console.log(`  #${t.number}: ${t.name} (${elapsed} min)`);
+        }
+        console.log(`  Use: task done <id> --force --force-reason "timeout" para liberar`);
+      }
+    }
+
     if (context?.last_checkpoint) {
         console.log(`\nUltimo checkpoint:`);
         console.log(`  ${context.last_checkpoint}`);
@@ -266,7 +204,7 @@ export function contextExport(options: { task?: string; json?: boolean; specId?:
             };
 
             // Obter standards para o agente da task
-            const domain = task.agent?.split("-")[0] || "all";
+            const domain = domainToScope(getAgentDomain(task.agent));
             standards = db
                 .query(
                     `SELECT * FROM standards
@@ -363,7 +301,7 @@ export function contextDetail(section: string, json: boolean = false, specId?: s
         "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1"
     ).get(spec.id) as any;
 
-    const domain = runningTask?.agent?.split("-")[0] || "all";
+    const domain = domainToScope(getAgentDomain(runningTask?.agent));
 
     let output = "";
 

package/context/assembly.ts

@@ -52,18 +52,26 @@ export function assembleSections(header: string, sections: ContextSection[]): st
     if (output.length > MAX_CONTEXT_SIZE) {
         const parts = output.split('\n### ');
         let trimmed = parts[0]; // Sempre manter header
+        let breakIndex = parts.length;
 
         for (let i = 1; i < parts.length; i++) {
             const candidate = trimmed + '\n### ' + parts[i];
             if (candidate.length > MAX_CONTEXT_SIZE - 200) {
+                breakIndex = i;
                 break;
             }
             trimmed = candidate;
         }
 
-        const omittedSections = parts.length - trimmed.split('\n### ').length;
-        if (omittedSections > 0) {
-            trimmed += `\n\n[CONTEXTO TRUNCADO: ${omittedSections} secao(oes) omitida(s) por limite de ${MAX_CONTEXT_SIZE} chars. Use: context-export para contexto completo]`;
+        // Coletar nomes das secoes omitidas
+        const omittedNames: string[] = [];
+        for (let i = breakIndex; i < parts.length; i++) {
+            const name = parts[i].split('\n')[0].trim();
+            if (name) omittedNames.push(name);
+        }
+
+        if (omittedNames.length > 0) {
+            trimmed += `\n\n[CONTEXTO TRUNCADO: ${omittedNames.length} secao(oes) omitida(s) (${omittedNames.join(', ')}). Use: codexa context detail <secao>]`;
         }
 
         output = trimmed;
@@ -71,12 +79,3 @@ export function assembleSections(header: string, sections: ContextSection[]): st
 
     return output;
 }
-
-// v9.3: Secoes relevantes por tipo de agente.
-// Agentes nao listados recebem TODAS as secoes (comportamento atual).
-export const AGENT_SECTIONS: Record<string, string[]> = {
-  "testing-unit":          ["STANDARDS", "DECISOES", "ALERTAS", "PATTERNS", "UTILITIES", "HINTS"],
-  "deep-explore":          ["STACK", "ARQUITETURA"],
-  "security-specialist":   ["STANDARDS", "DECISOES", "ALERTAS", "STACK", "HINTS"],
-  "expert-code-reviewer":  ["STANDARDS", "DECISOES", "ARQUITETURA", "UTILITIES", "ALERTAS", "HINTS"],
-};