@codexa/cli 9.0.1 → 9.0.3

package/commands/task.ts

@@ -1,10 +1,12 @@
 import { getDb } from "../db/connection";
-import { initSchema, getPatternsForFiles, getPatternsByScope, addSessionSummary, getRecentReasoning } from "../db/schema";
+import { initSchema, getPatternsForFiles, getPatternsByScope, getRecentReasoning, claimTask } 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";
 
 export function taskNext(json: boolean = false): void {
   initSchema();
@@ -17,11 +19,9 @@ export function taskNext(json: boolean = false): void {
   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
@@ -119,20 +119,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 +232,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 +262,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 +280,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 +348,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) {
@@ -494,73 +436,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`);