@codexa/cli 8.6.15 → 9.0.1

package/commands/task.ts

@@ -3,7 +3,7 @@ import { initSchema, getPatternsForFiles, getPatternsByScope, addSessionSummary,
 import { enforceGate } from "../gates/validator";
 import { parseSubagentReturn, formatValidationErrors } from "../protocol/subagent-protocol";
 import { processSubagentReturn, formatProcessResult } from "../protocol/process-return";
-import { getContextForSubagent } from "./utils";
+import { getContextForSubagent, getMinimalContextForSubagent } from "./utils";
 import { getUnreadKnowledgeForTask } from "./knowledge";
 
 export function taskNext(json: boolean = false): void {
@@ -101,7 +101,7 @@ 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): void {
+export function taskStart(ids: string, json: boolean = false, fullContext: boolean = false): void {
   initSchema();
   enforceGate("task-start");
 
@@ -144,10 +144,33 @@ export function taskStart(ids: string, json: boolean = false): void {
     spec.id,
   ]);
 
+  // v9.0: Mostrar resumo de knowledge relevante antes de iniciar
+  const allKnowledge = db.query(
+    `SELECT * FROM knowledge
+     WHERE spec_id = ? AND severity IN ('critical', 'warning')
+     ORDER BY severity DESC, created_at DESC
+     LIMIT 10`
+  ).all(spec.id) as any[];
+
+  if (allKnowledge.length > 0 && !json) {
+    console.log(`\n[i] Knowledge ativo (${allKnowledge.length}):`);
+    for (const k of allKnowledge.slice(0, 5)) {
+      const icon = k.severity === 'critical' ? '[X]' : '[!]';
+      console.log(`  ${icon} ${k.content}`);
+    }
+    if (allKnowledge.length > 5) {
+      console.log(`  ... +${allKnowledge.length - 5} mais`);
+    }
+    console.log();
+  }
+
   if (json) {
     // NOVO: Incluir contexto COMPLETO para cada task
     const contexts = startedTasks.map((task) => {
-      const contextText = getContextForSubagent(task.id);
+      // v9.0: Usar contexto minimo por padrao, expandido via --full-context
+      const contextText = fullContext
+        ? getContextForSubagent(task.id)
+        : getMinimalContextForSubagent(task.id);
       const unreadKnowledge = getUnreadKnowledgeForTask(spec.id, task.id);
 
       // NOVO v7.4: Buscar implementation patterns relevantes
@@ -196,8 +219,9 @@ export function taskStart(ids: string, json: boolean = false): void {
         files: taskFiles,
         // AVISO PARA O ORQUESTRADOR - NAO EXECUTE, DELEGUE
         _orchestratorWarning: "NAO execute esta task diretamente. Use Task tool com subagent_type='general-purpose' para delegar. O campo 'subagentContext' abaixo e o prompt para o SUBAGENT.",
-        // Contexto completo para o subagent (NAO para o orquestrador)
+        // Contexto para o subagent (NAO para o orquestrador)
         context: contextText,
+        contextMode: fullContext ? "full" : "minimal",
         // Knowledge nao lido (broadcast de outras tasks)
         unreadKnowledge: unreadKnowledge.map((k: any) => ({
           id: k.id,
@@ -237,6 +261,13 @@ CHECKLIST OBRIGATORIO (verifique ANTES de retornar):
 - [ ] 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(),
         // Instrucoes de retorno para o SUBAGENT
         subagentReturnProtocol: `
@@ -246,19 +277,20 @@ FORMATO DE RETORNO (apos criar os arquivos):
   "summary": "Resumo do que foi feito (10-500 chars)",
   "files_created": ["path/arquivo.ts"],
   "files_modified": ["path/outro.ts"],
-  "patterns_discovered": ["Pattern identificado"],
-  "decisions_made": [{"title": "...", "decision": "..."}],
-  "blockers": ["Se status != completed"],
-  "knowledge_to_broadcast": [{"category": "discovery|pattern|constraint", "content": "...", "severity": "info|warning|critical"}],
   "reasoning": {
-    "approach": "Como voce abordou o problema (RECOMENDADO)",
+    "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"}]
 }
 
-IMPORTANTE: O campo "reasoning" ajuda a preservar contexto entre sessoes.
-Inclua pelo menos "approach" para explicar suas escolhas.
+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:
 {
@@ -401,17 +433,36 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
       : [];
   }
 
-  // Validar gates incluindo files-exist e standards-follow
+  // Validar gates incluindo files-exist, standards-follow e reasoning (v9.0)
   enforceGate("task-done", {
     taskId,
     checkpoint,
     files: expectedFiles,
     force: options.force,
     forceReason: options.forceReason,
+    subagentData: subagentData,
   });
 
   // Nota: Validacao de standards agora e feita pelo Gate 4.2 (standards-follow) em enforceGate
 
+  // v9.0: Atualizar patterns incrementalmente com arquivos da task
+  try {
+    if (subagentData && subagentData.status === "completed") {
+      const allFiles = [
+        ...(subagentData.files_created || []),
+        ...(subagentData.files_modified || []),
+      ];
+      const codeFiles = allFiles.filter((f: string) => /\.(ts|tsx|js|jsx)$/.test(f));
+
+      if (codeFiles.length > 0) {
+        const { updatePatternsIncremental } = require("./patterns");
+        updatePatternsIncremental(codeFiles, task.number);
+      }
+    }
+  } catch {
+    // Nao-critico: nao falhar task done por atualizacao de patterns
+  }
+
   // Marcar como done
   db.run(
     "UPDATE tasks SET status = 'done', checkpoint = ?, completed_at = ? WHERE id = ?",

package/commands/utils.ts

@@ -345,6 +345,102 @@ export function contextExport(options: { task?: string; json?: boolean; }): void
     console.log(JSON.stringify(exportData, null, 2));
 }
 
+// v9.0: Contexto minimo para subagent (max ~2KB)
+const MAX_MINIMAL_CONTEXT = 2048;
+
+export function getMinimalContextForSubagent(taskId: number): string {
+    initSchema();
+    const db = getDb();
+
+    const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
+    if (!task) return "ERRO: Task nao encontrada";
+
+    const spec = db.query("SELECT * FROM specs WHERE id = ?").get(task.spec_id) as any;
+    const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(task.spec_id) as any;
+
+    const taskFiles = task.files ? JSON.parse(task.files) : [];
+    const domain = task.agent?.split("-")[0] || "all";
+
+    // 1. Standards REQUIRED apenas (nao recommended)
+    const requiredStandards = db.query(
+        `SELECT rule FROM standards
+         WHERE enforcement = 'required' AND (scope = 'all' OR scope = ?)
+         LIMIT 10`
+    ).all(domain) as any[];
+
+    // 2. Blockers CRITICAL apenas
+    const criticalBlockers = db.query(
+        `SELECT content FROM knowledge
+         WHERE spec_id = ? AND severity = 'critical'
+         ORDER BY created_at DESC LIMIT 5`
+    ).all(task.spec_id) as any[];
+
+    // 3. Contradicoes (se existir)
+    let contradictions: any[] = [];
+    try {
+        contradictions = findContradictions(task.spec_id);
+    } catch { /* ignore */ }
+
+    // 4. Decisoes da task anterior (dependency direta)
+    const dependsOn = task.depends_on ? JSON.parse(task.depends_on) : [];
+    let depDecisions: any[] = [];
+    if (dependsOn.length > 0) {
+        const placeholders = dependsOn.map(() => '?').join(',');
+        const depTasks = db.query(
+            `SELECT id FROM tasks WHERE spec_id = ? AND number IN (${placeholders})`
+        ).all(task.spec_id, ...dependsOn) as any[];
+
+        for (const dt of depTasks) {
+            const reasoning = db.query(
+                `SELECT thought FROM reasoning_log
+                 WHERE spec_id = ? AND task_id = ? AND category = 'recommendation'
+                 ORDER BY created_at DESC LIMIT 2`
+            ).all(task.spec_id, dt.id) as any[];
+            depDecisions.push(...reasoning);
+        }
+    }
+
+    // Montar output minimo
+    let output = `## CONTEXTO MINIMO (Task #${task.number})
+
+**Feature:** ${spec.name}
+**Objetivo:** ${context?.objective || "N/A"}
+**Arquivos:** ${taskFiles.join(", ") || "Nenhum especificado"}
+`;
+
+    if (requiredStandards.length > 0) {
+        output += `\n**Standards (OBRIGATORIOS):**\n${requiredStandards.map((s: any) => `- ${s.rule}`).join("\n")}\n`;
+    }
+
+    if (criticalBlockers.length > 0) {
+        output += `\n**BLOCKERS CRITICOS:**\n${criticalBlockers.map((b: any) => `[X] ${b.content}`).join("\n")}\n`;
+    }
+
+    if (contradictions.length > 0) {
+        output += `\n**CONTRADICOES:**\n${contradictions.map((c: any) => `[!] "${c.decision1}" <-> "${c.decision2}"`).join("\n")}\n`;
+    }
+
+    if (depDecisions.length > 0) {
+        output += `\n**Recomendacoes de tasks anteriores:**\n${depDecisions.map((d: any) => `- ${d.thought}`).join("\n")}\n`;
+    }
+
+    output += `
+**Contexto expandido**: Se precisar de mais contexto, execute:
+  codexa context detail standards    # Todos os standards
+  codexa context detail decisions    # Todas as decisoes
+  codexa context detail patterns     # Patterns do projeto
+  codexa context detail knowledge    # Knowledge completo
+  codexa context detail architecture # Analise arquitetural
+`;
+
+    // Truncar se exceder limite
+    if (output.length > MAX_MINIMAL_CONTEXT) {
+        output = output.substring(0, MAX_MINIMAL_CONTEXT - 100) + "\n\n[CONTEXTO TRUNCADO - use: codexa context detail <secao>]\n";
+    }
+
+    return output;
+}
+
 // Funcao helper para formatar contexto para subagent (uso interno)
 // v8.1: Contexto COMPLETO mas ESTRUTURADO - todas as fontes relevantes incluidas
 export function getContextForSubagent(taskId: number): string {
@@ -873,6 +969,154 @@ function filterRelevantStandards(standards: any[], taskFiles: string[]): any[] {
     });
 }
 
+export function contextDetail(section: string, json: boolean = false): void {
+    initSchema();
+    const db = getDb();
+
+    const spec = db
+        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
+        .get() as any;
+
+    if (!spec) {
+        console.error("\nNenhuma feature ativa.\n");
+        process.exit(1);
+    }
+
+    // Encontrar task running (para contexto relevante)
+    const runningTask = db.query(
+        "SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1"
+    ).get(spec.id) as any;
+
+    const domain = runningTask?.agent?.split("-")[0] || "all";
+
+    let output = "";
+
+    switch (section) {
+        case "standards": {
+            const standards = db.query(
+                "SELECT * FROM standards WHERE scope = 'all' OR scope = ? ORDER BY enforcement DESC, category"
+            ).all(domain) as any[];
+
+            if (json) { console.log(JSON.stringify({ standards })); return; }
+
+            output = `Standards (${standards.length}):\n`;
+            for (const s of standards) {
+                output += `\n[${s.enforcement.toUpperCase()}] ${s.category}: ${s.rule}`;
+                if (s.examples) {
+                    try {
+                        const examples = JSON.parse(s.examples);
+                        if (examples.length > 0) output += `\n  Exemplos: ${examples.slice(0, 2).join(", ")}`;
+                    } catch { /* ignore */ }
+                }
+                if (s.anti_examples) {
+                    try {
+                        const anti = JSON.parse(s.anti_examples);
+                        if (anti.length > 0) output += `\n  Anti-exemplos: ${anti.slice(0, 2).join(", ")}`;
+                    } catch { /* ignore */ }
+                }
+            }
+            break;
+        }
+
+        case "decisions": {
+            const decisions = db.query(
+                "SELECT * FROM decisions WHERE spec_id = ? AND status = 'active' ORDER BY created_at DESC"
+            ).all(spec.id) as any[];
+
+            if (json) { console.log(JSON.stringify({ decisions })); return; }
+
+            output = `Decisoes ativas (${decisions.length}):\n`;
+            for (const d of decisions) {
+                output += `\n[${d.id}] ${d.title}`;
+                output += `\n  Decisao: ${d.decision}`;
+                if (d.rationale) output += `\n  Racional: ${d.rationale}`;
+                output += `\n  Task: #${d.task_ref} | ${d.created_at}`;
+            }
+            break;
+        }
+
+        case "patterns": {
+            const patterns = db.query(
+                "SELECT * FROM implementation_patterns ORDER BY category, name"
+            ).all() as any[];
+
+            if (json) { console.log(JSON.stringify({ patterns })); return; }
+
+            output = `Patterns (${patterns.length}):\n`;
+            for (const p of patterns) {
+                output += `\n[${p.category}] ${p.name} (${p.scope})`;
+                output += `\n  Applies to: ${p.applies_to}`;
+                output += `\n  Confidence: ${(p.confidence * 100).toFixed(0)}%`;
+                if (p.template) {
+                    const preview = p.template.length > 300 ? p.template.substring(0, 300) + "..." : p.template;
+                    output += `\n  Template:\n${preview}`;
+                }
+                const anti = p.anti_patterns ? JSON.parse(p.anti_patterns) : [];
+                if (anti.length > 0) {
+                    output += `\n  Anti-patterns: ${anti.join("; ")}`;
+                }
+            }
+            break;
+        }
+
+        case "knowledge": {
+            const knowledge = db.query(
+                "SELECT k.*, t.number as task_number FROM knowledge k LEFT JOIN tasks t ON k.task_origin = t.id WHERE k.spec_id = ? ORDER BY k.severity DESC, k.created_at DESC LIMIT 50"
+            ).all(spec.id) as any[];
+
+            if (json) { console.log(JSON.stringify({ knowledge })); return; }
+
+            output = `Knowledge (${knowledge.length}):\n`;
+            for (const k of knowledge) {
+                const icon = k.severity === 'critical' ? '[X]' : k.severity === 'warning' ? '[!]' : '[i]';
+                output += `\n${icon} #${k.id} (${k.category}) Task #${k.task_number || '?'}`;
+                output += `\n  ${k.content}`;
+            }
+            break;
+        }
+
+        case "architecture": {
+            const analysis = getArchitecturalAnalysisForSpec(spec.name, spec.id);
+            if (!analysis) {
+                output = "Nenhuma analise arquitetural encontrada.";
+                break;
+            }
+
+            if (json) { console.log(JSON.stringify({ analysis })); return; }
+
+            output = `Analise Arquitetural: ${analysis.id}\n`;
+            output += `Status: ${analysis.status}\n`;
+            if (analysis.approach) output += `\nAbordagem:\n${analysis.approach}\n`;
+            if (analysis.risks) {
+                try {
+                    const risks = JSON.parse(analysis.risks);
+                    output += `\nRiscos (${risks.length}):\n`;
+                    for (const r of risks) {
+                        output += `  - ${r.description} (${r.probability}/${r.impact}) -> ${r.mitigation}\n`;
+                    }
+                } catch { /* ignore */ }
+            }
+            if (analysis.decisions) {
+                try {
+                    const decisions = JSON.parse(analysis.decisions);
+                    output += `\nDecisoes (${decisions.length}):\n`;
+                    for (const d of decisions) {
+                        output += `  - ${d.decision}: ${d.rationale || ''}\n`;
+                    }
+                } catch { /* ignore */ }
+            }
+            break;
+        }
+
+        default:
+            console.error(`\nSecao invalida: ${section}`);
+            console.error("Secoes validas: standards, decisions, patterns, knowledge, architecture\n");
+            process.exit(1);
+    }
+
+    console.log(output || "\nNenhum dado encontrado.\n");
+}
+
 export function recover(options: {
     list?: boolean;
     snapshot?: string;

package/gates/typecheck-validator.ts

@@ -0,0 +1,174 @@
+/**
+ * Gate 4.5: Typecheck Validator
+ *
+ * Executa verificacao de tipos nos arquivos criados/modificados pelo subagent.
+ * Requer tsconfig.json no projeto.
+ */
+
+import { existsSync } from "fs";
+import { spawnSync } from "child_process";
+import { resolve, dirname } from "path";
+
+export interface TypecheckResult {
+  passed: boolean;
+  errors: TypecheckError[];
+  skipped: boolean;
+  reason?: string;
+}
+
+export interface TypecheckError {
+  file: string;
+  line: number;
+  column: number;
+  message: string;
+  code: string;
+}
+
+/**
+ * Encontra o tsconfig.json mais proximo subindo diretorios
+ */
+function findTsConfig(startDir: string): string | null {
+  let dir = startDir;
+  const root = resolve("/");
+
+  while (dir !== root) {
+    const candidate = resolve(dir, "tsconfig.json");
+    if (existsSync(candidate)) return candidate;
+    dir = dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Detecta o runtime do projeto para escolher o comando tsc
+ */
+function detectTscCommand(): string[] {
+  const bunCheck = spawnSync("bun", ["--version"], { encoding: "utf-8", timeout: 3000 });
+  if (!bunCheck.error) return ["bunx", "tsc"];
+
+  const npxCheck = spawnSync("npx", ["--version"], { encoding: "utf-8", timeout: 3000 });
+  if (!npxCheck.error) return ["npx", "tsc"];
+
+  const tscCheck = spawnSync("tsc", ["--version"], { encoding: "utf-8", timeout: 3000 });
+  if (!tscCheck.error) return ["tsc"];
+
+  return [];
+}
+
+/**
+ * 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 (isRelevant) {
+      errors.push({
+        file: normalizedFile,
+        line: parseInt(lineNum),
+        column: parseInt(col),
+        message,
+        code,
+      });
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Executa typecheck nos arquivos especificados
+ */
+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" };
+  }
+
+  // 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 (!tsconfig) {
+    return { passed: true, errors: [], skipped: true, reason: "tsconfig.json nao encontrado" };
+  }
+
+  // Detectar comando tsc
+  const tscCmd = detectTscCommand();
+  if (tscCmd.length === 0) {
+    return { passed: true, errors: [], skipped: true, reason: "tsc nao encontrado (instale typescript)" };
+  }
+
+  // Executar tsc --noEmit
+  const result = spawnSync(
+    tscCmd[0],
+    [...tscCmd.slice(1), "--noEmit", "--project", tsconfig],
+    {
+      encoding: "utf-8",
+      timeout: 60000,
+      maxBuffer: 5 * 1024 * 1024,
+      cwd: dirname(tsconfig),
+    }
+  );
+
+  if (result.error) {
+    return { passed: true, errors: [], skipped: true, reason: `Erro ao executar tsc: ${result.error.message}` };
+  }
+
+  // Parsear erros, filtrando apenas os dos arquivos relevantes
+  const output = (result.stdout || "") + (result.stderr || "");
+  const errors = parseTscOutput(output, tsFiles);
+
+  return {
+    passed: errors.length === 0,
+    errors,
+    skipped: false,
+  };
+}
+
+/**
+ * Formata resultado para exibicao no CLI
+ */
+export function printTypecheckResult(result: TypecheckResult): void {
+  if (result.skipped) {
+    console.log(`\n[i] Typecheck pulado: ${result.reason}`);
+    return;
+  }
+
+  if (result.passed) {
+    console.log(`\n[ok] Typecheck: sem erros nos arquivos da task`);
+    return;
+  }
+
+  console.error(`\n[X] TYPECHECK: ${result.errors.length} erro(s) encontrado(s)\n`);
+  for (const err of result.errors) {
+    console.error(`  ${err.file}:${err.line}:${err.column}`);
+    console.error(`    ${err.code}: ${err.message}`);
+    console.error();
+  }
+}

package/gates/validator.ts

@@ -2,6 +2,7 @@ import { getDb } from "../db/connection";
 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 { findDuplicateUtilities } from "../db/schema";
 
@@ -48,6 +49,11 @@ const GATES: Record<string, GateCheck[]> = {
       message: "Dependencias pendentes",
       resolution: "Complete as tasks dependentes primeiro",
     },
+    {
+      check: "no-critical-blockers",
+      message: "Knowledge critico nao resolvido",
+      resolution: "Verifique os blockers com: knowledge list --severity critical. Reconheca com: knowledge resolve <id>",
+    },
   ],
   "task-done": [
     {
@@ -75,6 +81,16 @@ const GATES: Record<string, GateCheck[]> = {
       message: "Duplicacao de utilities detectada (DRY)",
       resolution: "Importe do arquivo existente ou use --force --force-reason para bypass",
     },
+    {
+      check: "reasoning-provided",
+      message: "Reasoning obrigatorio ausente no retorno do subagent",
+      resolution: "O subagent deve incluir 'reasoning.approach' (min 20 chars) no retorno JSON",
+    },
+    {
+      check: "typecheck-pass",
+      message: "Erros de tipo encontrados nos arquivos da task",
+      resolution: "Corrija os erros TypeScript ou use --force --force-reason para bypass",
+    },
   ],
   "review-start": [
     {
@@ -275,6 +291,78 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       return { passed: true };
     }
 
+    case "typecheck-pass": {
+      if (context.force) {
+        logGateBypass(context.taskId, "typecheck-pass", context.forceReason);
+        return { passed: true };
+      }
+
+      if (!context.files || context.files.length === 0) return { passed: true };
+
+      const typecheckResult = runTypecheck(context.files);
+
+      printTypecheckResult(typecheckResult);
+
+      if (typecheckResult.skipped) return { passed: true };
+
+      return {
+        passed: typecheckResult.passed,
+        details: typecheckResult.errors.map(e => `${e.file}:${e.line} ${e.code}: ${e.message}`).join("\n"),
+      };
+    }
+
+    case "no-critical-blockers": {
+      const spec = getActiveSpec();
+      if (!spec) return { passed: true };
+
+      const allKnowledge = db
+        .query(
+          `SELECT k.*, t.number as task_number, t.name as task_name
+           FROM knowledge k
+           LEFT JOIN tasks t ON k.task_origin = t.id
+           WHERE k.spec_id = ? AND k.severity = 'critical'
+           ORDER BY k.created_at DESC`
+        )
+        .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;
+        }
+      });
+
+      if (unresolved.length === 0) return { passed: true };
+
+      const details = unresolved.map((k: any) => {
+        const origin = k.task_name ? `Task #${k.task_number} (${k.task_name})` : `Task ID ${k.task_origin}`;
+        return `[CRITICAL] ${k.content} (origem: ${origin})`;
+      }).join("\n");
+
+      return {
+        passed: false,
+        details: `${unresolved.length} blocker(s) critico(s) nao resolvido(s):\n${details}`,
+      };
+    }
+
+    case "reasoning-provided": {
+      if (!context.subagentData) return { passed: true };
+
+      const data = context.subagentData;
+      if (data.status !== "completed") return { passed: true };
+
+      if (!data.reasoning?.approach || data.reasoning.approach.length < 20) {
+        return {
+          passed: false,
+          details: "O subagent retornou status 'completed' sem reasoning.approach (min 20 chars)",
+        };
+      }
+      return { passed: true };
+    }
+
     default:
       return { passed: true };
   }