@codexa/cli 9.0.2 → 9.0.4

package/gates/validator.ts

@@ -5,11 +5,14 @@ import { validateAgainstStandards, printValidationResult } from "./standards-val
 import { runTypecheck, printTypecheckResult } from "./typecheck-validator";
 import { extractUtilitiesFromFile } from "../commands/patterns";
 import { findDuplicateUtilities } from "../db/schema";
+import { GateError, RecoverySuggestion } from "../errors";
+import { resolveSpecOrNull } from "../commands/spec-resolver";
 
 export interface GateResult {
   passed: boolean;
   reason?: string;
   resolution?: string;
+  recovery?: RecoverySuggestion;
 }
 
 interface GateCheck {
@@ -63,8 +66,8 @@ const GATES: Record<string, GateCheck[]> = {
     },
     {
       check: "checkpoint-filled",
-      message: "Checkpoint obrigatorio",
-      resolution: "Forneca --checkpoint 'resumo do que foi feito'",
+      message: "Checkpoint obrigatorio (min 10 chars)",
+      resolution: "Forneca --checkpoint 'resumo do que foi feito' (min 10 caracteres)",
     },
     {
       check: "files-exist",
@@ -108,9 +111,59 @@ const GATES: Record<string, GateCheck[]> = {
   ],
 };
 
-function getActiveSpec(): any {
-  const db = getDb();
-  return db.query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1").get();
+// v9.3: Estrategias de recuperacao por gate — diagnostico + passos concretos
+const RECOVERY_STRATEGIES: Record<string, (details?: string) => RecoverySuggestion> = {
+  "standards-follow": (details) => ({
+    diagnostic: `Violacoes de standards detectadas:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Revise as violacoes listadas acima",
+      "Corrija o codigo para seguir os standards obrigatorios",
+      "Ou use --force --force-reason 'motivo' para bypass (auditado no review)",
+    ],
+    command: "codexa context detail standards",
+  }),
+  "dry-check": (details) => ({
+    diagnostic: `Utilities duplicadas encontradas:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Verifique as utilities existentes",
+      "Importe do arquivo existente em vez de recriar",
+      "Se intencional, use --force --force-reason 'motivo'",
+    ],
+  }),
+  "typecheck-pass": (details) => ({
+    diagnostic: `Erros TypeScript encontrados:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Corrija os erros de tipo listados",
+      "Verifique imports e definicoes de tipo",
+      "Se erros em deps externas, use --force --force-reason 'motivo'",
+    ],
+  }),
+  "files-exist": (details) => ({
+    diagnostic: `Arquivos esperados nao encontrados:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Verifique se o subagent usou Write/Edit para criar os arquivos",
+      "Confirme que os caminhos em --files correspondem aos arquivos reais",
+      "Verifique conteudo valido (nao vazio, estrutura correta)",
+    ],
+  }),
+  "checkpoint-filled": (details) => ({
+    diagnostic: `Checkpoint invalido: ${details || "muito curto ou incompleto"}`,
+    steps: [
+      "Forneca --checkpoint com resumo do que foi feito (min 10 chars)",
+      "Descreva O QUE foi feito, nao apenas 'feito' ou 'ok'",
+    ],
+  }),
+  "reasoning-provided": () => ({
+    diagnostic: "Subagent retornou sem reasoning.approach adequado",
+    steps: [
+      "Inclua 'reasoning.approach' no retorno JSON do subagent (min 20 chars)",
+      "Descreva COMO o problema foi abordado",
+    ],
+  }),
+};
+
+function getActiveSpec(specId?: string): any {
+  return resolveSpecOrNull(specId);
 }
 
 function executeCheck(check: string, context: any): { passed: boolean; details?: string } {
@@ -118,24 +171,24 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
 
   switch (check) {
     case "plan-exists": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       return { passed: spec !== null };
     }
 
     case "has-tasks": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       if (!spec) return { passed: false };
       const count = db.query("SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?").get(spec.id) as any;
       return { passed: count.c > 0 };
     }
 
     case "phase-is-checking": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       return { passed: spec?.phase === "checking" };
     }
 
     case "spec-approved": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       return { passed: spec?.approved_at !== null };
     }
 
@@ -164,13 +217,15 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
     }
 
     case "checkpoint-filled": {
-      return {
-        passed: !!context.checkpoint && context.checkpoint.length >= 10,
-      };
+      const cp = context.checkpoint?.trim() || "";
+      if (cp.length < 10) {
+        return { passed: false, details: "Checkpoint deve ter pelo menos 10 caracteres" };
+      }
+      return { passed: true };
     }
 
     case "all-tasks-done": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       if (!spec) return { passed: false };
       const pending = db.query(
         "SELECT number FROM tasks WHERE spec_id = ? AND status != 'done'"
@@ -182,7 +237,7 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
     }
 
     case "review-exists": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       if (!spec) return { passed: false };
       const review = db.query("SELECT * FROM review WHERE spec_id = ?").get(spec.id);
       return { passed: review !== null };
@@ -192,12 +247,38 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       if (!context.files || context.files.length === 0) return { passed: true };
 
       // v8.0: Validar não apenas existência, mas conteúdo mínimo
+      // v9.2: Validar que arquivo foi modificado DURANTE a task
+      // v9.3: Tolerancia de 5s para clock skew em sandbox
+      const MTIME_TOLERANCE_MS = 5000;
       const issues: string[] = [];
 
+      // Buscar started_at da task para comparacao temporal
+      let taskStartTime: number | null = null;
+      if (context.taskId) {
+        const taskRow = db.query("SELECT started_at FROM tasks WHERE id = ?").get(context.taskId) as any;
+        if (taskRow?.started_at) {
+          taskStartTime = new Date(taskRow.started_at).getTime();
+        }
+      }
+
       for (const file of context.files) {
         const validation = validateFileContent(file);
         if (!validation.valid) {
           issues.push(`${file}: ${validation.reason}`);
+          continue;
+        }
+        // Verificar que arquivo foi tocado durante a task (com tolerancia)
+        if (taskStartTime) {
+          try {
+            const stat = statSync(file);
+            const mtime = stat.mtimeMs;
+            if (mtime < (taskStartTime - MTIME_TOLERANCE_MS)) {
+              const diffSec = Math.round((taskStartTime - mtime) / 1000);
+              issues.push(`${file}: arquivo nao foi modificado durante esta task (mtime ${diffSec}s anterior ao start)`);
+            }
+          } catch {
+            // statSync falhou — arquivo pode nao existir (ja reportado por validateFileContent)
+          }
         }
       }
 
@@ -312,7 +393,7 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
     }
 
     case "no-critical-blockers": {
-      const spec = getActiveSpec();
+      const spec = getActiveSpec(context.specId);
       if (!spec) return { passed: true };
 
       const allKnowledge = db
@@ -326,13 +407,10 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
         .all(spec.id) as any[];
 
       const unresolved = allKnowledge.filter((k: any) => {
-        if (!k.acknowledged_by) return true;
-        try {
-          const acked = JSON.parse(k.acknowledged_by) as number[];
-          return acked.length === 0;
-        } catch {
-          return true;
-        }
+        const hasAck = db.query(
+          "SELECT 1 FROM knowledge_acknowledgments WHERE knowledge_id = ?"
+        ).get(k.id);
+        return !hasAck;
       });
 
       if (unresolved.length === 0) return { passed: true };
@@ -392,12 +470,16 @@ export function validateGate(command: string, context: any = {}): GateResult {
     const result = executeCheck(gate.check, context);
 
     if (!result.passed) {
+      const recoveryFn = RECOVERY_STRATEGIES[gate.check];
+      const recovery = recoveryFn ? recoveryFn(result.details) : undefined;
+
       return {
         passed: false,
         reason: result.details
           ? `${gate.message}: ${result.details}`
           : gate.message,
         resolution: gate.resolution,
+        recovery,
       };
     }
   }
@@ -409,14 +491,17 @@ export function enforceGate(command: string, context: any = {}): void {
   const result = validateGate(command, context);
 
   if (!result.passed) {
-    console.error(`\nBLOQUEADO: ${result.reason}`);
-    console.error(`Resolva: ${result.resolution}\n`);
-    process.exit(1);
+    throw new GateError(
+      result.reason || "Gate falhou",
+      result.resolution || "Verifique o estado atual",
+      command,
+      result.recovery
+    );
   }
 }
 
 // v8.0: Validar conteúdo de arquivos criados (não apenas existência)
-interface FileValidationResult {
+export interface FileValidationResult {
   valid: boolean;
   reason?: string;
 }
@@ -456,7 +541,7 @@ function validateFileContent(filePath: string): FileValidationResult {
   }
 }
 
-function validateByExtension(ext: string, content: string): FileValidationResult {
+export function validateByExtension(ext: string, content: string): FileValidationResult {
   const trimmed = content.trim();
 
   switch (ext) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.2",
+  "version": "9.0.4",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {
@@ -16,6 +16,8 @@
   ],
   "scripts": {
     "cli": "bun run workflow.ts",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
     "install": "npm publish --access public"
   },
   "engines": {

package/protocol/process-return.ts

@@ -11,7 +11,7 @@
 
 import { getDb } from "../db/connection";
 import { SubagentReturn, Knowledge } from "./subagent-protocol";
-import { addReasoning, addGraphRelation, getRelatedFiles, upsertUtility } from "../db/schema";
+import { addReasoning, addGraphRelation, upsertUtility, getNextDecisionId } from "../db/schema";
 import { extractUtilitiesFromFile, inferScopeFromPath } from "../commands/patterns";
 
 interface ProcessResult {
@@ -26,18 +26,6 @@ interface ProcessResult {
   errors: string[];
 }
 
-function getNextDecisionId(specId: string): string {
-  const db = getDb();
-  const last = db
-    .query("SELECT id FROM decisions WHERE spec_id = ? ORDER BY created_at DESC LIMIT 1")
-    .get(specId) as any;
-
-  if (!last) return "DEC-001";
-
-  const num = parseInt(last.id.replace("DEC-", "")) + 1;
-  return `DEC-${num.toString().padStart(3, "0")}`;
-}
-
 /**
  * Processa o retorno de um subagent e registra automaticamente
  * todos os dados extraidos no banco
@@ -85,87 +73,32 @@ export function processSubagentReturn(
     }
   }
 
-  // 2. Registrar Decisions
+  // 2. Registrar Decisions (com retry para collision de IDs concorrentes)
+  const savedDecisionIds: string[] = [];
   if (data.decisions_made && data.decisions_made.length > 0) {
     for (const dec of data.decisions_made) {
-      try {
-        const decisionId = getNextDecisionId(specId);
-        db.run(
-          `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
-           VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
-          [decisionId, specId, taskNumber, dec.title, dec.decision, dec.rationale || null, now]
-        );
-        result.decisionsAdded++;
-      } catch (e) {
-        result.errors.push(`Erro ao registrar decision: ${(e as Error).message}`);
-      }
-    }
-  }
-
-  // 2b. v8.3: Deteccao automatica de contradicoes entre decisoes
-  if (data.decisions_made && data.decisions_made.length > 0) {
-    try {
-      const existingDecisions = db.query(
-        "SELECT id, title, decision FROM decisions WHERE spec_id = ? AND status = 'active'"
-      ).all(specId) as any[];
-
-      const allTaskFiles = [...data.files_created, ...data.files_modified];
-
-      for (const newDec of data.decisions_made) {
-        for (const existingDec of existingDecisions) {
-          // Skip se mesma decisao (recem adicionada)
-          if (existingDec.title === newDec.title) continue;
-
-          const newDecLower = `${newDec.title} ${newDec.decision}`.toLowerCase();
-          const existDecLower = `${existingDec.title} ${existingDec.decision}`.toLowerCase();
-
-          // Verificar overlap de arquivos
-          const existingDecFiles = getRelatedFiles(existingDec.id, "decision");
-          const fileOverlap = allTaskFiles.some(f => existingDecFiles.includes(f));
-
-          if (fileOverlap) {
-            // Heuristica de keywords opostos
-            const opposites = [
-              ['usar', 'nao usar'], ['usar', 'evitar'],
-              ['use', 'avoid'], ['add', 'remove'],
-              ['incluir', 'excluir'], ['habilitar', 'desabilitar'],
-              ['enable', 'disable'], ['create', 'delete'],
-              ['client', 'server'], ['sync', 'async'],
-            ];
-
-            let isContradiction = false;
-            for (const [word1, word2] of opposites) {
-              if ((newDecLower.includes(word1) && existDecLower.includes(word2)) ||
-                  (newDecLower.includes(word2) && existDecLower.includes(word1))) {
-                isContradiction = true;
-                break;
-              }
-            }
-
-            if (isContradiction) {
-              const newDecId = db.query(
-                "SELECT id FROM decisions WHERE spec_id = ? AND title = ? ORDER BY created_at DESC LIMIT 1"
-              ).get(specId, newDec.title) as any;
-
-              if (newDecId) {
-                addGraphRelation(specId, {
-                  sourceType: "decision",
-                  sourceId: newDecId.id,
-                  targetType: "decision",
-                  targetId: existingDec.id,
-                  relation: "contradicts",
-                  strength: 0.7,
-                  metadata: { reason: "Arquivos sobrepostos com semantica oposta" },
-                });
-                result.relationsAdded++;
-              }
-            }
+      let retries = 3;
+      let inserted = false;
+      while (retries > 0 && !inserted) {
+        try {
+          const decisionId = getNextDecisionId(specId);
+          db.run(
+            `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
+            [decisionId, specId, taskNumber, dec.title, dec.decision, dec.rationale || null, now]
+          );
+          savedDecisionIds.push(decisionId);
+          result.decisionsAdded++;
+          inserted = true;
+        } catch (e: any) {
+          if (e.message?.includes("UNIQUE constraint") && retries > 1) {
+            retries--;
+            continue;
           }
+          result.errors.push(`Erro ao registrar decision: ${(e as Error).message}`);
+          break;
         }
       }
-    } catch (e) {
-      // Nao-critico: nao falhar processamento por deteccao de contradicoes
-      result.errors.push(`Aviso contradicoes: ${(e as Error).message}`);
     }
   }
 
@@ -331,10 +264,9 @@ export function processSubagentReturn(
       result.relationsAdded++;
     }
 
-    // Relação: decision -> arquivos (se houver decisions)
-    if (data.decisions_made) {
-      for (const dec of data.decisions_made) {
-        const decisionId = getNextDecisionId(specId);
+    // Relação: decision -> arquivos (usa IDs salvos na seção 2, não gera novos)
+    if (savedDecisionIds.length > 0) {
+      for (const decisionId of savedDecisionIds) {
         for (const file of [...data.files_created, ...data.files_modified]) {
           addGraphRelation(specId, {
             sourceType: "decision",