@codexa/cli 9.0.7 → 9.0.8

package/gates/typecheck-validator.ts

@@ -1,14 +1,20 @@
 /**
- * Gate 4.5: Typecheck Validator
+ * Gate 4.5: Typecheck Validator (Stack-Agnostic)
  *
  * Executa verificacao de tipos nos arquivos criados/modificados pelo subagent.
- * Requer tsconfig.json no projeto.
+ * Suporta multiplas stacks via presets automaticos + comando custom configuravel.
+ *
+ * Prioridade: custom_command > preset da stack > skip
  */
 
 import { existsSync } from "fs";
 import { spawnSync } from "child_process";
 import { resolve, dirname } from "path";
 
+// ═══════════════════════════════════════════════════════════════
+// INTERFACES
+// ═══════════════════════════════════════════════════════════════
+
 export interface TypecheckResult {
   passed: boolean;
   errors: TypecheckError[];
@@ -24,136 +30,334 @@ export interface TypecheckError {
   code: string;
 }
 
-/**
- * Encontra o tsconfig.json mais proximo subindo diretorios
- */
-function findTsConfig(startDir: string): string | null {
-  let dir = startDir;
+interface TypecheckPreset {
+  fileFilter: RegExp;
+  setup: (files: string[]) => string[] | null; // Returns command args or null if unavailable
+  errorParser: (output: string, files: string[]) => TypecheckError[];
+}
+
+// ═══════════════════════════════════════════════════════════════
+// PRESETS POR STACK
+// ═══════════════════════════════════════════════════════════════
+
+const TYPECHECK_PRESETS: Record<string, TypecheckPreset> = {
+  node: {
+    fileFilter: /\.(ts|tsx)$/,
+    setup: (files) => {
+      const tsconfig = findConfigFile(files, "tsconfig.json");
+      if (!tsconfig) return null;
+      const tscCmd = detectCommand(["bunx tsc", "npx tsc", "tsc"]);
+      if (!tscCmd) return null;
+      return [...tscCmd.split(" "), "--noEmit", "--project", tsconfig];
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/),
+  },
+
+  go: {
+    fileFilter: /\.go$/,
+    setup: () => {
+      if (!isCommandAvailable("go")) return null;
+      return ["go", "vet", "./..."];
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+):(\d+):(\d+):\s+(.+)$/),
+  },
+
+  dotnet: {
+    fileFilter: /\.cs$/,
+    setup: (files) => {
+      const csproj = findConfigFile(files, "*.csproj");
+      if (!csproj && !isCommandAvailable("dotnet")) return null;
+      return ["dotnet", "build", "--no-restore", "--nologo", "-v", "q"];
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+)\((\d+),(\d+)\):\s+error\s+(CS\d+):\s+(.+)$/),
+  },
+
+  rust: {
+    fileFilter: /\.rs$/,
+    setup: () => {
+      if (!isCommandAvailable("cargo")) return null;
+      return ["cargo", "check", "--message-format", "short"];
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+):(\d+):(\d+):\s+error(?:\[(\w+)\])?:\s+(.+)$/),
+  },
+
+  python: {
+    fileFilter: /\.py$/,
+    setup: () => {
+      // Tentar mypy primeiro, depois pyright
+      const checker = detectCommand(["mypy", "pyright"]);
+      if (!checker) return null;
+      if (checker === "mypy") return ["mypy", "--no-error-summary"];
+      return ["pyright"];
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+):(\d+):(?:(\d+):)?\s+error:\s+(.+)$/),
+  },
+
+  flutter: {
+    fileFilter: /\.dart$/,
+    setup: () => {
+      if (!isCommandAvailable("dart")) return null;
+      return ["dart", "analyze", "--no-preamble"];
+    },
+    errorParser: parseColonSeparatedErrors(/^\s*(.+):(\d+):(\d+)\s+.*error.*[-•]\s+(.+)$/),
+  },
+
+  jvm: {
+    fileFilter: /\.(java|kt|kts)$/,
+    setup: () => {
+      // Gradle ou Maven
+      if (existsSync("gradlew") || existsSync("gradlew.bat")) {
+        const cmd = process.platform === "win32" ? "gradlew.bat" : "./gradlew";
+        return [cmd, "compileJava", "-q"];
+      }
+      if (existsSync("pom.xml") && isCommandAvailable("mvn")) {
+        return ["mvn", "compile", "-q"];
+      }
+      return null;
+    },
+    errorParser: parseColonSeparatedErrors(/^(.+):(\d+):\s+error:\s+(.+)$/),
+  },
+};
+
+// ═══════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════
+
+function isCommandAvailable(cmd: string): boolean {
+  const result = spawnSync(cmd, ["--version"], { encoding: "utf-8", timeout: 3000 });
+  return !result.error;
+}
+
+function detectCommand(candidates: string[]): string | null {
+  for (const cmd of candidates) {
+    const bin = cmd.split(" ")[0];
+    if (isCommandAvailable(bin)) return cmd;
+  }
+  return null;
+}
+
+function findConfigFile(files: string[], pattern: string): string | null {
+  // Buscar no cwd primeiro
+  const cwdCandidate = resolve(process.cwd(), pattern.replace("*.", ""));
+  if (!pattern.includes("*") && existsSync(cwdCandidate)) return cwdCandidate;
+
+  // Buscar subindo diretorios a partir dos arquivos
+  const existingFiles = files.filter(f => existsSync(f));
+  if (existingFiles.length === 0) return null;
+
+  let dir = dirname(resolve(existingFiles[0]));
   const root = resolve("/");
 
   while (dir !== root) {
-    const candidate = resolve(dir, "tsconfig.json");
-    if (existsSync(candidate)) return candidate;
+    if (pattern.includes("*")) {
+      // Glob simples: *.csproj
+      try {
+        const entries = require("fs").readdirSync(dir) as string[];
+        const ext = pattern.replace("*", "");
+        const match = entries.find((e: string) => e.endsWith(ext));
+        if (match) return resolve(dir, match);
+      } catch { /* continue */ }
+    } else {
+      const candidate = resolve(dir, pattern);
+      if (existsSync(candidate)) return candidate;
+    }
     dir = dirname(dir);
   }
   return null;
 }
 
+function isFileRelevant(errorFile: string, relevantFiles: string[]): boolean {
+  const normalized = errorFile.replace(/\\/g, "/");
+  return relevantFiles.some(rf => {
+    const normalizedRf = rf.replace(/\\/g, "/");
+    return (
+      normalized.endsWith(normalizedRf) ||
+      normalized.includes(normalizedRf) ||
+      normalizedRf.endsWith(normalized) ||
+      normalizedRf.includes(normalized)
+    );
+  });
+}
+
 /**
- * Detecta o runtime do projeto para escolher o comando tsc
+ * Factory para parsers de erro com formato "file:line:col: message"
+ * Aceita regex com 4 ou 5 capture groups:
+ *   5 groups: (file, line, col, code, message)
+ *   4 groups: (file, line, col, message) — code sera "ERROR"
  */
-function detectTscCommand(): string[] {
-  const bunCheck = spawnSync("bun", ["--version"], { encoding: "utf-8", timeout: 3000 });
-  if (!bunCheck.error) return ["bunx", "tsc"];
+function parseColonSeparatedErrors(regex: RegExp) {
+  return (output: string, relevantFiles: string[]): TypecheckError[] => {
+    const errors: TypecheckError[] = [];
+    const lines = output.split(/\r?\n/);
 
-  const npxCheck = spawnSync("npx", ["--version"], { encoding: "utf-8", timeout: 3000 });
-  if (!npxCheck.error) return ["npx", "tsc"];
+    for (const line of lines) {
+      const match = line.match(regex);
+      if (!match) continue;
 
-  const tscCheck = spawnSync("tsc", ["--version"], { encoding: "utf-8", timeout: 3000 });
-  if (!tscCheck.error) return ["tsc"];
+      let file: string, lineNum: string, col: string, code: string, message: string;
 
-  return [];
-}
+      if (match.length >= 6) {
+        [, file, lineNum, col, code, message] = match;
+      } else if (match.length >= 5) {
+        [, file, lineNum, col, message] = match;
+        code = "ERROR";
+      } else {
+        continue;
+      }
 
-/**
- * Parseia output do tsc em erros estruturados
- */
-function parseTscOutput(output: string, relevantFiles: string[]): TypecheckError[] {
-  const errors: TypecheckError[] = [];
-  const lines = output.split(/\r?\n/);
-
-  // Formato: file(line,col): error TSxxxx: message
-  const errorRegex = /^(.+)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
-
-  for (const line of lines) {
-    const match = line.match(errorRegex);
-    if (!match) continue;
-
-    const [, file, lineNum, col, code, message] = match;
-    const normalizedFile = file.replace(/\\/g, "/");
-
-    // Filtrar: apenas erros nos arquivos relevantes
-    const isRelevant = relevantFiles.some(rf => {
-      const normalizedRf = rf.replace(/\\/g, "/");
-      return (
-        normalizedFile.endsWith(normalizedRf) ||
-        normalizedFile.includes(normalizedRf) ||
-        normalizedRf.endsWith(normalizedFile) ||
-        normalizedRf.includes(normalizedFile)
-      );
-    });
+      if (!isFileRelevant(file, relevantFiles)) continue;
 
-    if (isRelevant) {
       errors.push({
-        file: normalizedFile,
-        line: parseInt(lineNum),
-        column: parseInt(col),
-        message,
-        code,
+        file: file.replace(/\\/g, "/"),
+        line: parseInt(lineNum) || 0,
+        column: parseInt(col) || 0,
+        message: message?.trim() || "",
+        code: code || "ERROR",
       });
     }
-  }
 
-  return errors;
+    return errors;
+  };
 }
 
 /**
- * Executa typecheck nos arquivos especificados
+ * Resolve ecosystems da stack JSON do projeto
  */
-export function runTypecheck(files: string[]): TypecheckResult {
-  // Filtrar apenas arquivos TS/TSX
-  const tsFiles = files.filter(f => /\.(ts|tsx)$/.test(f) && existsSync(f));
-
-  if (tsFiles.length === 0) {
-    return { passed: true, errors: [], skipped: true, reason: "Nenhum arquivo TypeScript" };
+function resolveEcosystems(stackJson: string | null): string[] {
+  if (!stackJson) return [];
+  try {
+    const stack = JSON.parse(stackJson);
+    // Formato novo (detectUniversal): tem ecosystems array
+    if (Array.isArray(stack.ecosystems)) return stack.ecosystems;
+    // Formato legado: tem chaves frontend/backend
+    if (stack.frontend || stack.backend) {
+      const ecosystems: string[] = [];
+      const stackStr = JSON.stringify(stack).toLowerCase();
+      if (stackStr.includes("typescript") || stackStr.includes("next") || stackStr.includes("react") || stackStr.includes("node") || stackStr.includes("bun")) ecosystems.push("node");
+      if (stackStr.includes("go") || stackStr.includes("golang")) ecosystems.push("go");
+      if (stackStr.includes("dotnet") || stackStr.includes("c#") || stackStr.includes("csharp")) ecosystems.push("dotnet");
+      if (stackStr.includes("python") || stackStr.includes("django") || stackStr.includes("flask") || stackStr.includes("fastapi")) ecosystems.push("python");
+      if (stackStr.includes("rust") || stackStr.includes("cargo")) ecosystems.push("rust");
+      if (stackStr.includes("flutter") || stackStr.includes("dart")) ecosystems.push("flutter");
+      if (stackStr.includes("java") || stackStr.includes("kotlin") || stackStr.includes("spring") || stackStr.includes("gradle")) ecosystems.push("jvm");
+      return ecosystems;
+    }
+    return [];
+  } catch {
+    return [];
   }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// EXECUCAO DO TYPECHECK
+// ═══════════════════════════════════════════════════════════════
+
+function runCustomCommand(customCommand: string, files: string[]): TypecheckResult {
+  const parts = customCommand.trim().split(/\s+/);
+  const [cmd, ...args] = parts;
 
-  // Encontrar tsconfig.json (primeiro no cwd, depois no diretorio dos arquivos)
-  let tsconfig = findTsConfig(process.cwd());
-  if (!tsconfig) {
-    const firstFileDir = dirname(resolve(tsFiles[0]));
-    tsconfig = findTsConfig(firstFileDir);
+  if (!isCommandAvailable(cmd)) {
+    return { passed: true, errors: [], skipped: true, reason: `Comando custom '${cmd}' nao encontrado no PATH` };
   }
-  if (!tsconfig) {
-    return { passed: true, errors: [], skipped: true, reason: "tsconfig.json nao encontrado" };
+
+  const result = spawnSync(cmd, args, {
+    encoding: "utf-8",
+    timeout: 60000,
+    maxBuffer: 5 * 1024 * 1024,
+    cwd: process.cwd(),
+  });
+
+  if (result.error) {
+    return { passed: true, errors: [], skipped: true, reason: `Erro ao executar '${customCommand}': ${result.error.message}` };
   }
 
-  // Detectar comando tsc
-  const tscCmd = detectTscCommand();
-  if (tscCmd.length === 0) {
-    return { passed: true, errors: [], skipped: true, reason: "tsc nao encontrado (instale typescript)" };
+  const output = (result.stdout || "") + (result.stderr || "");
+  // Comando custom: verificar exit code (0 = pass, non-zero = fail)
+  // Parsear erros com formato generico file:line:col
+  const genericParser = parseColonSeparatedErrors(/^(.+):(\d+):(?:(\d+):?)?\s+(?:error|Error):\s+(.+)$/);
+  const errors = genericParser(output, files);
+
+  // Se nao encontrou erros parseados mas exit code != 0, reportar output bruto
+  if (result.status !== 0 && errors.length === 0) {
+    const trimmedOutput = output.trim().slice(0, 500);
+    return {
+      passed: false,
+      errors: [{ file: "typecheck", line: 0, column: 0, message: trimmedOutput, code: `EXIT_${result.status}` }],
+      skipped: false,
+    };
   }
 
-  // Executar tsc --noEmit
-  const result = spawnSync(
-    tscCmd[0],
-    [...tscCmd.slice(1), "--noEmit", "--project", tsconfig],
-    {
+  return { passed: errors.length === 0, errors, skipped: false };
+}
+
+function runPresetTypecheck(ecosystems: string[], files: string[]): TypecheckResult {
+  // Tentar cada ecosystem detectado ate encontrar um que funcione
+  for (const eco of ecosystems) {
+    const preset = TYPECHECK_PRESETS[eco];
+    if (!preset) continue;
+
+    const relevantFiles = files.filter(f => preset.fileFilter.test(f) && existsSync(f));
+    if (relevantFiles.length === 0) continue;
+
+    const cmdArgs = preset.setup(relevantFiles);
+    if (!cmdArgs) continue;
+
+    const result = spawnSync(cmdArgs[0], cmdArgs.slice(1), {
       encoding: "utf-8",
       timeout: 60000,
       maxBuffer: 5 * 1024 * 1024,
-      cwd: dirname(tsconfig),
+      cwd: process.cwd(),
+    });
+
+    if (result.error) {
+      return { passed: true, errors: [], skipped: true, reason: `Erro ao executar ${cmdArgs[0]}: ${result.error.message}` };
     }
-  );
 
-  if (result.error) {
-    return { passed: true, errors: [], skipped: true, reason: `Erro ao executar tsc: ${result.error.message}` };
+    const output = (result.stdout || "") + (result.stderr || "");
+    const errors = preset.errorParser(output, relevantFiles);
+
+    return { passed: errors.length === 0, errors, skipped: false };
   }
 
-  // Parsear erros, filtrando apenas os dos arquivos relevantes
-  const output = (result.stdout || "") + (result.stderr || "");
-  const errors = parseTscOutput(output, tsFiles);
+  return { passed: true, errors: [], skipped: true, reason: "Nenhum typechecker disponivel para a stack detectada" };
+}
 
-  return {
-    passed: errors.length === 0,
-    errors,
-    skipped: false,
-  };
+// ═══════════════════════════════════════════════════════════════
+// API PUBLICA
+// ═══════════════════════════════════════════════════════════════
+
+export function runTypecheck(files: string[], options?: { customCommand?: string | null; stackJson?: string | null }): TypecheckResult {
+  const existingFiles = files.filter(f => existsSync(f));
+  if (existingFiles.length === 0) {
+    return { passed: true, errors: [], skipped: true, reason: "Nenhum arquivo encontrado no disco" };
+  }
+
+  // Prioridade 1: Comando custom configurado pelo usuario
+  if (options?.customCommand) {
+    return runCustomCommand(options.customCommand, existingFiles);
+  }
+
+  // Prioridade 2: Preset automatico baseado na stack detectada
+  const ecosystems = resolveEcosystems(options?.stackJson || null);
+  if (ecosystems.length > 0) {
+    return runPresetTypecheck(ecosystems, existingFiles);
+  }
+
+  // Prioridade 3: Fallback — tentar detectar stack pelos arquivos
+  const fallbackEcosystems: string[] = [];
+  for (const [eco, preset] of Object.entries(TYPECHECK_PRESETS)) {
+    if (existingFiles.some(f => preset.fileFilter.test(f))) {
+      fallbackEcosystems.push(eco);
+    }
+  }
+
+  if (fallbackEcosystems.length > 0) {
+    return runPresetTypecheck(fallbackEcosystems, existingFiles);
+  }
+
+  return { passed: true, errors: [], skipped: true, reason: "Stack nao detectada e nenhum typechecker configurado" };
 }
 
-/**
- * Formata resultado para exibicao no CLI
- */
 export function printTypecheckResult(result: TypecheckResult): void {
   if (result.skipped) {
     console.log(`\n[i] Typecheck pulado: ${result.reason}`);

package/gates/validator.ts

@@ -3,10 +3,12 @@ import { existsSync, readFileSync, statSync } from "fs";
 import { extname } from "path";
 import { validateAgainstStandards, printValidationResult } from "./standards-validator";
 import { runTypecheck, printTypecheckResult } from "./typecheck-validator";
-import { extractUtilitiesFromFile } from "../commands/patterns";
+import { extractUtilitiesFromFile, inferScopeFromPath } from "../commands/patterns";
 import { findDuplicateUtilities } from "../db/schema";
 import { GateError, RecoverySuggestion } from "../errors";
 import { resolveSpecOrNull } from "../commands/spec-resolver";
+import { detectConflicts } from "../commands/decide";
+import { getAgentDomain, domainToScope } from "../context/domains";
 
 export interface GateResult {
   passed: boolean;
@@ -92,7 +94,12 @@ const GATES: Record<string, GateCheck[]> = {
     {
       check: "typecheck-pass",
       message: "Erros de tipo encontrados nos arquivos da task",
-      resolution: "Corrija os erros TypeScript ou use --force --force-reason para bypass",
+      resolution: "Corrija os erros de tipo ou use --force --force-reason para bypass",
+    },
+    {
+      check: "decision-conflicts",
+      message: "Conflito entre decisoes do subagent e decisoes ativas",
+      resolution: "Revise com: decisions. Revogue: decide:revoke <id>. Substitua: decide:supersede <id> <title> <decision>. Ou: --force --force-reason",
     },
   ],
   "review-start": [
@@ -131,11 +138,12 @@ const RECOVERY_STRATEGIES: Record<string, (details?: string) => RecoverySuggesti
     ],
   }),
   "typecheck-pass": (details) => ({
-    diagnostic: `Erros TypeScript encontrados:\n${details || "Detalhes nao disponiveis"}`,
+    diagnostic: `Erros de tipo 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'",
+      "Para configurar typechecker custom: codexa project set --typecheck-command '<comando>'",
     ],
   }),
   "files-exist": (details) => ({
@@ -153,6 +161,16 @@ const RECOVERY_STRATEGIES: Record<string, (details?: string) => RecoverySuggesti
       "Descreva O QUE foi feito, nao apenas 'feito' ou 'ok'",
     ],
   }),
+  "decision-conflicts": (details) => ({
+    diagnostic: `Conflitos de decisao:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Revise decisoes existentes: decisions",
+      "Revogue a antiga: decide:revoke <id> --reason 'motivo'",
+      "Ou substitua: decide:supersede <id> <title> <decision>",
+      "Se intencional: --force --force-reason 'motivo'",
+    ],
+    command: "codexa decisions",
+  }),
   "reasoning-provided": () => ({
     diagnostic: "Subagent retornou sem reasoning.approach adequado",
     steps: [
@@ -249,9 +267,17 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       // 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
+      // v9.6: Confiar no protocolo quando subagent reporta arquivos (sandbox)
       const MTIME_TOLERANCE_MS = 5000;
       const issues: string[] = [];
 
+      // Construir set de arquivos reportados pelo subagent (podem estar em sandbox)
+      const subagentReportedFiles = new Set<string>();
+      if (context.subagentData) {
+        for (const f of context.subagentData.files_created || []) subagentReportedFiles.add(f);
+        for (const f of context.subagentData.files_modified || []) subagentReportedFiles.add(f);
+      }
+
       // Buscar started_at da task para comparacao temporal
       let taskStartTime: number | null = null;
       if (context.taskId) {
@@ -262,6 +288,17 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       }
 
       for (const file of context.files) {
+        if (!existsSync(file)) {
+          // Arquivo nao existe no disco — verificar se veio de subagent
+          if (subagentReportedFiles.has(file)) {
+            // Subagent reportou o arquivo via protocolo → confiar
+            // (arquivo pode estar em sandbox, sera materializado no commit)
+            continue;
+          }
+          issues.push(`${file}: arquivo nao encontrado no disco`);
+          continue;
+        }
+
         const validation = validateFileContent(file);
         if (!validation.valid) {
           issues.push(`${file}: ${validation.reason}`);
@@ -277,7 +314,7 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
               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)
+            // statSync falhou — arquivo pode nao existir (ja reportado acima)
           }
         }
       }
@@ -300,7 +337,7 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
 
       // Obter agente da task
       const task = db.query("SELECT * FROM tasks WHERE id = ?").get(context.taskId) as any;
-      const agentDomain = task?.agent?.split("-")[0] || "all";
+      const agentDomain = domainToScope(getAgentDomain(task?.agent));
 
       // Validar arquivos contra standards
       const result = validateAgainstStandards(context.files, agentDomain);
@@ -331,13 +368,22 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
 
       for (const file of context.files) {
         if (!existsSync(file)) continue;
+
+        const fileScope = inferScopeFromPath(file);
+        // Arquivos de teste nao conflitam com production code
+        if (fileScope === "testing") continue;
+
         const utilities = extractUtilitiesFromFile(file);
 
         for (const util of utilities) {
           const existing = findDuplicateUtilities(util.name, file);
-          if (existing.length > 0) {
+          // Filtrar: duplicatas em scope "testing" nao contam
+          const realDuplicates = existing.filter(
+            (e: any) => inferScopeFromPath(e.file_path) !== "testing"
+          );
+          if (realDuplicates.length > 0) {
             duplicates.push(
-              `"${util.name}" (${util.type}) em ${file} -- ja existe em: ${existing.map((e: any) => e.file_path).join(", ")}`
+              `"${util.name}" (${util.type}) em ${file} -- ja existe em: ${realDuplicates.map((e: any) => e.file_path).join(", ")}`
             );
           }
         }
@@ -380,7 +426,12 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
 
       if (!context.files || context.files.length === 0) return { passed: true };
 
-      const typecheckResult = runTypecheck(context.files);
+      // Buscar stack e custom command do projeto
+      const projectRow = db.query("SELECT stack, typecheck_command FROM project WHERE id = 'default'").get() as any;
+      const typecheckResult = runTypecheck(context.files, {
+        customCommand: projectRow?.typecheck_command || null,
+        stackJson: projectRow?.stack || null,
+      });
 
       printTypecheckResult(typecheckResult);
 
@@ -426,6 +477,40 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       };
     }
 
+    case "decision-conflicts": {
+      if (context.force) {
+        logGateBypass(context.taskId, "decision-conflicts", context.forceReason);
+        return { passed: true };
+      }
+
+      if (!context.subagentData?.decisions_made?.length) return { passed: true };
+
+      const dcTask = db.query("SELECT * FROM tasks WHERE id = ?").get(context.taskId) as any;
+      if (!dcTask) return { passed: true };
+
+      const existingDecisions = db
+        .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
+        .all(dcTask.spec_id) as any[];
+      if (existingDecisions.length === 0) return { passed: true };
+
+      const allConflicts: string[] = [];
+      for (const dec of context.subagentData.decisions_made) {
+        const analysis = detectConflicts(dec.title, dec.decision, existingDecisions);
+        if (analysis.hasConflict) {
+          for (const conflict of analysis.conflictingDecisions) {
+            allConflicts.push(
+              `"${dec.title}" conflita com ${conflict.id} ("${conflict.title}"): ${conflict.reason}`
+            );
+          }
+        }
+      }
+
+      if (allConflicts.length > 0) {
+        return { passed: false, details: allConflicts.join("\n") };
+      }
+      return { passed: true };
+    }
+
     case "reasoning-provided": {
       if (!context.subagentData) return { passed: true };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.7",
+  "version": "9.0.8",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {