@codexa/cli 9.0.2 → 9.0.4

package/commands/task.ts

@@ -1,27 +1,26 @@
 import { getDb } from "../db/connection";
-import { initSchema, getPatternsForFiles, getPatternsByScope, addSessionSummary, getRecentReasoning } from "../db/schema";
+import { initSchema, getPatternsForFiles, getPatternsByScope, getRecentReasoning, claimTask, recordAgentPerformance } from "../db/schema";
 import { enforceGate } from "../gates/validator";
 import { parseSubagentReturn, formatValidationErrors } from "../protocol/subagent-protocol";
 import { processSubagentReturn, formatProcessResult } from "../protocol/process-return";
 import { getContextForSubagent, getMinimalContextForSubagent } from "./utils";
 import { getUnreadKnowledgeForTask } from "./knowledge";
+import { loadTemplate } from "../templates/loader";
+import { TaskStateError, ValidationError, KnowledgeBlockError } from "../errors";
+import { resolveSpec, resolveSpecOrNull } from "./spec-resolver";
 
-export function taskNext(json: boolean = false): void {
+export function taskNext(json: boolean = false, specId?: string): void {
   initSchema();
 
   const db = getDb();
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase = 'implementing' ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
+  const spec = resolveSpecOrNull(specId, ["implementing"]);
 
   if (!spec) {
     if (json) {
       console.log(JSON.stringify({ available: [], message: "Nenhuma feature em implementacao" }));
-    } else {
-      console.error("\nNenhuma feature em fase de implementacao.");
-      console.error("Aprove o plano com: check approve\n");
+      return;
     }
-    process.exit(1);
+    throw new TaskStateError("Nenhuma feature em fase de implementacao.\nAprove o plano com: check approve");
   }
 
   // Buscar tasks pendentes cujas dependencias estao todas concluidas
@@ -101,16 +100,14 @@ export function taskNext(json: boolean = false): void {
   console.log(`Use: task start <id> ou task start <id1>,<id2>,...\n`);
 }
 
-export function taskStart(ids: string, json: boolean = false, fullContext: boolean = false): void {
+export function taskStart(ids: string, json: boolean = false, fullContext: boolean = false, specId?: string): void {
   initSchema();
   enforceGate("task-start");
 
   const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase = 'implementing' ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
+  const spec = resolveSpec(specId, ["implementing"]);
 
   const taskIds = ids.split(",").map((s) => parseInt(s.trim()));
   const startedTasks: any[] = [];
@@ -119,20 +116,19 @@ export function taskStart(ids: string, json: boolean = false, fullContext: boole
     const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
 
     if (!task) {
-      console.error(`\nTask #${taskId} nao encontrada.\n`);
-      process.exit(2);
-    }
-
-    if (task.status !== "pending") {
-      console.error(`\nTask #${task.number} nao esta pendente (status: ${task.status}).\n`);
-      process.exit(2);
+      throw new TaskStateError(`Task #${taskId} nao encontrada.`);
     }
 
     // Validar dependencias para esta task especifica
     enforceGate("task-start", { taskId });
 
-    // Marcar como running
-    db.run("UPDATE tasks SET status = 'running' WHERE id = ?", [taskId]);
+    // Claim atomico: UPDATE ... WHERE status = 'pending'
+    if (!claimTask(taskId)) {
+      const current = db.query("SELECT status FROM tasks WHERE id = ?").get(taskId) as any;
+      throw new TaskStateError(
+        `Task #${task.number} nao pode ser iniciada (status atual: ${current?.status || "desconhecido"}).`
+      );
+    }
 
     startedTasks.push(task);
   }
@@ -233,77 +229,15 @@ export function taskStart(ids: string, json: boolean = false, fullContext: boole
         // NOVO v7.4: Implementation patterns extraidos do projeto
         implementationPatterns: formattedPatterns,
         // Contexto para o SUBAGENT (o orquestrador deve passar isso via Task tool)
-        subagentContext: `
-╔══════════════════════════════════════════════════════════════════════════════╗
-║  DIRETIVA CRITICA: USE Write/Edit PARA CRIAR OS ARQUIVOS                     ║
-║  NAO descreva. NAO planeje. NAO simule. EXECUTE AGORA.                       ║
-║  Se retornar sem usar Write/Edit, a task FALHA.                              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-
-ARQUIVOS QUE VOCE DEVE CRIAR (use Write para cada um):
-${taskFiles.map(f => `  - ${f}`).join('\n') || '  (nenhum arquivo especificado - analise o contexto)'}
-
-╔══════════════════════════════════════════════════════════════════════════════╗
-║  POLLING OBRIGATORIO: Verifique blockers a cada 3 arquivos modificados       ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-
-ANTES de criar o 4o, 7o, 10o arquivo (a cada 3), execute:
-  codexa knowledge list --severity critical --unread
-
-Se retornar QUALQUER blocker:
-1. PARE imediatamente
-2. Retorne com status "blocked" e inclua o blocker encontrado
-3. NAO continue criando arquivos apos encontrar blocker
-
-CHECKLIST OBRIGATORIO (verifique ANTES de retornar):
-- [ ] Usei Write ou Edit para criar/modificar arquivos?
-- [ ] Verifiquei blockers a cada 3 arquivos?
-- [ ] Os arquivos que vou listar em files_created EXISTEM no disco?
-
-Se nao marcou todos os items, PARE e corrija AGORA.
-
-CONTEXTO ON-DEMAND: Se precisar de mais contexto alem do fornecido, execute:
-  codexa context detail standards    # Regras do projeto
-  codexa context detail decisions    # Decisoes tomadas
-  codexa context detail patterns     # Patterns de codigo
-  codexa context detail knowledge    # Discoveries de outras tasks
-NAO execute todos - apenas o que for NECESSARIO para sua task.
-`.trim(),
+        subagentContext: loadTemplate("subagent-context", {
+          filesList: taskFiles.map(f => `  - ${f}`).join('\n') || '  (nenhum arquivo especificado - analise o contexto)',
+        }),
         // Instrucoes de retorno para o SUBAGENT
-        subagentReturnProtocol: `
-FORMATO DE RETORNO (apos criar os arquivos):
-{
-  "status": "completed | blocked | needs_decision",
-  "summary": "Resumo do que foi feito (10-500 chars)",
-  "files_created": ["path/arquivo.ts"],
-  "files_modified": ["path/outro.ts"],
-  "reasoning": {
-    "approach": "OBRIGATORIO (min 20 chars): Como voce abordou o problema e POR QUE tomou essas decisoes",
-    "challenges": ["Desafios encontrados"],
-    "recommendations": "Sugestoes para proximas tasks"
-  },
-  "patterns_discovered": ["Pattern identificado"],
-  "decisions_made": [{"title": "...", "decision": "..."}],
-  "blockers": ["Se status != completed"],
-  "knowledge_to_broadcast": [{"category": "discovery|pattern|constraint", "content": "...", "severity": "info|warning|critical"}]
-}
-
-ATENCAO: O campo "reasoning.approach" e OBRIGATORIO para status "completed".
-Se retornar sem ele, Gate 4.4 BLOQUEIA a finalizacao da task.
-Descreva COMO abordou o problema, nao apenas O QUE fez.
-
-Se NAO conseguir criar arquivos (sem permissao, sem ferramentas), retorne:
-{
-  "status": "blocked",
-  "blockers": ["Descreva por que nao conseguiu criar os arquivos"]
-}
-
-Veja .claude/agents/PROTOCOL.md para detalhes completos.
-${formattedPatterns.length > 0 ? `
-PATTERNS: Voce recebeu ${formattedPatterns.length} implementation patterns extraidos do projeto.
-Use os TEMPLATES fornecidos para criar codigo CONSISTENTE com o projeto existente.
-` : ''}
-`.trim(),
+        subagentReturnProtocol: loadTemplate("subagent-return-protocol", {
+          patternsNote: formattedPatterns.length > 0
+            ? `\nPATTERNS: Voce recebeu ${formattedPatterns.length} implementation patterns extraidos do projeto.\nUse os TEMPLATES fornecidos para criar codigo CONSISTENTE com o projeto existente.\n`
+            : '',
+        }),
       };
     });
     console.log(JSON.stringify({ started: contexts }));
@@ -325,8 +259,7 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
   const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
 
   if (!task) {
-    console.error(`\nTask #${taskId} nao encontrada.\n`);
-    process.exit(2);
+    throw new TaskStateError(`Task #${taskId} nao encontrada.`);
   }
 
   const spec = db.query("SELECT * FROM specs WHERE id = ?").get(task.spec_id) as any;
@@ -344,10 +277,11 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     const parseResult = parseSubagentReturn(options.output);
 
     if (!parseResult.success) {
-      console.error(formatValidationErrors(parseResult));
-      console.error("\nTask NAO pode ser completada sem retorno valido.");
-      console.error("Corrija o formato do retorno do subagent e tente novamente.\n");
-      process.exit(2);
+      throw new ValidationError(
+        formatValidationErrors(parseResult) +
+        "\nTask NAO pode ser completada sem retorno valido." +
+        "\nCorrija o formato do retorno do subagent e tente novamente."
+      );
     }
 
     subagentData = parseResult.data!;
@@ -411,14 +345,19 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
         .filter((k: any) => k.severity === 'critical' && k.task_origin !== taskId);
     if (unackedCritical.length > 0) {
       if (!options.force) {
-        console.error(`\n[X] BLOQUEADO: ${unackedCritical.length} knowledge(s) critico(s) nao reconhecido(s):`);
-        for (const k of unackedCritical) {
-          console.error(`    [X] ${k.content} (de Task #${k.task_origin})`);
-        }
-        console.error(`\n    O subagent NAO verificou o polling obrigatorio.`);
-        console.error(`    Reconheca com: knowledge ack <id>`);
-        console.error(`    Ou force com: task done ${id} --checkpoint "..." --force --force-reason "motivo"\n`);
-        process.exit(1);
+        // Task permanece em "running" (subagent output ja processado acima).
+        // Nao pode ser marcada "done" ate knowledge ser reconhecido.
+        const items = unackedCritical.map(
+          (k: any) => `  [X] ${k.content} (de Task #${k.task_origin})`
+        ).join("\n");
+
+        throw new KnowledgeBlockError(
+          `BLOQUEADO: ${unackedCritical.length} knowledge(s) critico(s) nao reconhecido(s):\n${items}\n\n` +
+          `O subagent NAO verificou o polling obrigatorio.\n` +
+          `Reconheca com: knowledge ack <id>\n` +
+          `Ou force com: task done ${id} --checkpoint "..." --force --force-reason "motivo"`,
+          unackedCritical
+        );
       } else {
         console.log(`\n[!] AVISO: ${unackedCritical.length} knowledge(s) critico(s) ignorado(s) (--force usado)`);
         for (const k of unackedCritical) {
@@ -469,6 +408,30 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     [checkpoint, now, taskId]
   );
 
+  // v9.3: Registrar performance do agente
+  try {
+    const agentType = task.agent || "general-purpose";
+    const startedAt = task.started_at ? new Date(task.started_at).getTime() : Date.now();
+    const duration = Date.now() - startedAt;
+    const bypassCount = (db.query(
+      "SELECT COUNT(*) as c FROM gate_bypasses WHERE task_id = ?"
+    ).get(taskId) as any)?.c || 0;
+    const totalGates = 7;
+
+    recordAgentPerformance({
+      agentType,
+      specId: spec.id,
+      taskId,
+      gatesPassedFirstTry: Math.max(0, totalGates - bypassCount),
+      gatesTotal: totalGates,
+      bypassesUsed: bypassCount,
+      filesCreated: subagentData?.files_created?.length || 0,
+      filesModified: subagentData?.files_modified?.length || 0,
+      contextSizeBytes: 0,
+      executionDurationMs: duration,
+    });
+  } catch { /* nao-critico: nao falhar task done por tracking de performance */ }
+
   // Registrar artefatos se NAO veio do subagent (ja foi processado acima)
   if (!subagentData && options.files) {
     const files = options.files.split(",").map((s) => s.trim());
@@ -494,73 +457,15 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
     [checkpoint, now, spec.id]
   );
 
-  // Criar snapshot automatico COMPLETO
-  const allTasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
-  const allDecisions = db.query("SELECT * FROM decisions WHERE spec_id = ?").all(spec.id) as any[];
-  const allArtifacts = db.query("SELECT * FROM artifacts WHERE spec_id = ?").all(spec.id) as any[];
-  const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id);
-
-  const snapshotData = {
-    spec,
-    context,
-    tasks: allTasks,
-    decisions: allDecisions,
-    artifacts: allArtifacts,
-    checkpoint: options.checkpoint,
-    taskCompleted: task.number,
-    timestamp: now,
-  };
-  db.run("INSERT INTO snapshots (spec_id, data, trigger, created_at) VALUES (?, ?, 'auto', ?)", [
-    spec.id,
-    JSON.stringify(snapshotData),
-    now,
-  ]);
-
-  // v8.1: Gerar session summary automaticamente
-  try {
-    const taskDecisions = allDecisions.filter((d) => d.task_ref === task.number);
-    const taskArtifacts = allArtifacts.filter((a) => a.task_ref === task.number);
-    const blockers = db.query(
-      "SELECT content FROM knowledge WHERE spec_id = ? AND task_origin = ? AND category = 'blocker'"
-    ).all(spec.id, taskId) as any[];
-    const reasoning = getRecentReasoning(spec.id, 5);
-    const nextSteps: string[] = [];
-
-    // Extrair recommendations do reasoning
-    for (const r of reasoning) {
-      if (r.category === 'recommendation' && r.thought) {
-        nextSteps.push(r.thought);
-      }
-    }
-
-    // Se nao completou tudo, sugerir proximo passo
-    if (doneCount.c < totalCount.c) {
-      nextSteps.push(`Continuar implementacao: ${totalCount.c - doneCount.c} tasks restantes`);
-    } else {
-      nextSteps.push("Todas tasks concluidas. Iniciar review.");
-    }
-
-    addSessionSummary(spec.id, {
-      startTime: task.completed_at || now, // approximation
-      endTime: now,
-      summary: `Task #${task.number} (${task.name}) concluida. ${checkpoint}`,
-      decisions: taskDecisions.map((d: any) => `${d.title}: ${d.decision}`),
-      blockers: blockers.map((b: any) => b.content),
-      nextSteps,
-      tasksCompleted: 1,
-      filesCreated: taskArtifacts.filter((a: any) => a.action === 'created').length,
-      filesModified: taskArtifacts.filter((a: any) => a.action === 'modified').length,
-    });
-  } catch (e) {
-    // Session summary e best-effort, nao deve bloquear o fluxo
-  }
-
   console.log(`\nTask #${task.number} concluida!`);
   console.log(`Checkpoint: ${options.checkpoint}`);
   console.log(`Progresso: ${doneCount.c}/${totalCount.c} tasks`);
 
   if (doneCount.c === totalCount.c) {
     // Mostrar resumo completo da implementacao
+    const allTasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
+    const allDecisions = db.query("SELECT * FROM decisions WHERE spec_id = ?").all(spec.id) as any[];
+    const allArtifacts = db.query("SELECT * FROM artifacts WHERE spec_id = ?").all(spec.id) as any[];
     showImplementationSummary(spec.id, allTasks, allArtifacts, allDecisions);
   } else {
     console.log(`\nProximas tasks: task next\n`);

package/commands/utils.test.ts

@@ -0,0 +1,100 @@
+/**
+ * v9.3: Tests for AGENT_SECTIONS filtering (P3.1 — Context Intelligence)
+ */
+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");
+  });
+
+  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("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("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();
+  });
+
+  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
+  });
+});