@codexa/cli 9.0.25 → 9.0.26

package/commands/discover.ts

@@ -12,7 +12,7 @@ import {
   type UnifiedDetectionResult,
 } from "../detectors/loader";
 import { CodexaError } from "../errors";
-import { getGrepaiWorkspace } from "./patterns";
+import { getGrepaiWorkspace, detectSemanticPatterns, saveSemanticPatterns, isGrepaiAvailable } from "./patterns";
 
 interface StackDetection {
   frontend?: string;
@@ -274,8 +274,21 @@ export function discoverConfirm(): void {
   // Auto-setup: deep-explore agent
   ensureDeepExploreAgent();
 
+  // v10.2: Detect semantic patterns via grepai (if available)
+  let semanticCount = 0;
+  if (isGrepaiAvailable()) {
+    const workspace = getGrepaiWorkspace() || undefined;
+    const semanticPatterns = detectSemanticPatterns(workspace);
+    if (semanticPatterns.length > 0) {
+      semanticCount = saveSemanticPatterns(semanticPatterns);
+    }
+  }
+
   console.log("\nProjeto descoberto e configurado!");
   console.log(`Standards criados: ${standardsCount.c}`);
+  if (semanticCount > 0) {
+    console.log(`Patterns semanticos detectados: ${semanticCount}`);
+  }
   console.log("\nArquivo gerado: .codexa/standards.md");
   console.log("\nProximo passo: /codexa:feature para iniciar uma feature\n");
 }

package/commands/patterns.ts

@@ -372,6 +372,213 @@ export function updatePatternsIncremental(files: string[], taskNumber: number):
   }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// v10.2: DETECÇÃO SEMÂNTICA DE PATTERNS VIA GREPAI
+// Identifica patterns reais do projeto (error handling, data fetching,
+// component composition, etc.) usando busca semântica.
+// ═══════════════════════════════════════════════════════════════
+
+const SEMANTIC_PATTERN_QUERIES = [
+  { query: "error handling pattern", category: "error-handling", scope: "shared" },
+  { query: "data fetching and API call pattern", category: "data-fetching", scope: "frontend" },
+  { query: "component composition and reuse pattern", category: "component", scope: "frontend" },
+  { query: "service layer and dependency injection", category: "service", scope: "backend" },
+  { query: "state management pattern", category: "state", scope: "frontend" },
+  { query: "testing patterns and test utilities", category: "test", scope: "testing" },
+];
+
+export interface SemanticPattern {
+  name: string;
+  category: string;
+  scope: string;
+  files: string[];
+  confidence: number;
+  description: string;
+}
+
+export function detectSemanticPatterns(workspace?: string): SemanticPattern[] {
+  if (!isGrepaiAvailable()) return [];
+
+  const ws = workspace || getGrepaiWorkspace() || undefined;
+  const detected: SemanticPattern[] = [];
+
+  for (const { query, category, scope } of SEMANTIC_PATTERN_QUERIES) {
+    const results = searchWithGrepai(query, 5, ws);
+    if (results.length < 2) continue;
+
+    const avgScore = results.reduce((sum, r) => sum + r.score, 0) / results.length;
+    if (avgScore < 0.3) continue;
+
+    detected.push({
+      name: `${category}-pattern`,
+      category,
+      scope,
+      files: results.map(r => r.path),
+      confidence: Math.min(avgScore, 1),
+      description: `Semantic pattern detected: ${query} (${results.length} files, avg score ${avgScore.toFixed(2)})`,
+    });
+  }
+
+  return detected;
+}
+
+export function saveSemanticPatterns(patterns: SemanticPattern[]): number {
+  initSchema();
+  const db = getDb();
+  const now = new Date().toISOString();
+  let saved = 0;
+
+  for (const p of patterns) {
+    try {
+      const existing = db.query(
+        "SELECT id FROM implementation_patterns WHERE name = ?"
+      ).get(p.name) as any;
+
+      if (existing) {
+        db.run(
+          `UPDATE implementation_patterns SET
+            confidence = ?, examples = ?, extracted_from = ?, updated_at = ?
+           WHERE id = ?`,
+          [p.confidence, JSON.stringify(p.files.map(f => ({ path: f, relevance: p.confidence }))), p.files.length, now, existing.id]
+        );
+      } else {
+        db.run(
+          `INSERT INTO implementation_patterns
+            (category, name, scope, applies_to, structure, template, examples, confidence, extracted_from, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            p.category, p.name, p.scope,
+            `**/*`,
+            JSON.stringify({ source: "semantic", description: p.description }),
+            `[Semantic pattern - see examples for reference files]`,
+            JSON.stringify(p.files.map(f => ({ path: f, relevance: p.confidence }))),
+            p.confidence, p.files.length, now, now,
+          ]
+        );
+      }
+      saved++;
+    } catch { /* skip duplicates */ }
+  }
+
+  return saved;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// v10.2: PATTERN COMPLIANCE VALIDATION (used by Gate 4.7)
+// ═══════════════════════════════════════════════════════════════
+
+export interface PatternComplianceResult {
+  passed: boolean;
+  violations: Array<{ file: string; pattern: string; reason: string }>;
+  checked: number;
+}
+
+export function validatePatternCompliance(
+  files: string[],
+  minConfidence: number = 0.7
+): PatternComplianceResult {
+  initSchema();
+  const db = getDb();
+  const result: PatternComplianceResult = { passed: true, violations: [], checked: 0 };
+
+  if (files.length === 0) return result;
+
+  const allPatterns = db.query(
+    "SELECT * FROM implementation_patterns WHERE confidence >= ?"
+  ).all(minConfidence) as any[];
+
+  if (allPatterns.length === 0) return result;
+
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+
+    const matchingPatterns = allPatterns.filter(p => fileMatchesGlob(file, p.applies_to));
+    if (matchingPatterns.length === 0) continue;
+
+    const analysis = analyzeFile(file);
+    if (!analysis) continue;
+
+    result.checked++;
+
+    for (const pattern of matchingPatterns) {
+      let structure: any;
+      try { structure = JSON.parse(pattern.structure); } catch { continue; }
+
+      // Semantic patterns (source: "semantic") — use grepai if available
+      if (structure.source === "semantic") {
+        if (isGrepaiAvailable()) {
+          const ws = getGrepaiWorkspace() || undefined;
+          const grepaiResults = searchWithGrepai(
+            `file:${file} follows ${pattern.category} pattern`, 1, ws
+          );
+          if (grepaiResults.length > 0 && grepaiResults[0].score < 0.4) {
+            result.violations.push({
+              file,
+              pattern: pattern.name,
+              reason: `Low semantic match (${grepaiResults[0].score.toFixed(2)}) for ${pattern.category} pattern`,
+            });
+          }
+        }
+        continue;
+      }
+
+      // Structural patterns — check imports, hooks, conventions
+      if (structure.requiredImports) {
+        for (const imp of structure.requiredImports) {
+          if (!analysis.imports.includes(imp)) {
+            result.violations.push({
+              file,
+              pattern: pattern.name,
+              reason: `Missing required import: ${imp}`,
+            });
+          }
+        }
+      }
+
+      if (structure.requiredExports) {
+        for (const exp of structure.requiredExports) {
+          if (!analysis.exports.includes(exp)) {
+            result.violations.push({
+              file,
+              pattern: pattern.name,
+              reason: `Missing required export: ${exp}`,
+            });
+          }
+        }
+      }
+
+      if (structure.requiredDirectives) {
+        for (const dir of structure.requiredDirectives) {
+          if (!analysis.directives.includes(dir)) {
+            result.violations.push({
+              file,
+              pattern: pattern.name,
+              reason: `Missing required directive: "${dir}"`,
+            });
+          }
+        }
+      }
+
+      if (structure.commonHooks) {
+        const requiredHookCount = Math.ceil(structure.commonHooks.length * 0.3);
+        const matchedHooks = structure.commonHooks.filter(
+          (h: string) => analysis.hooksUsed.includes(h)
+        );
+        if (matchedHooks.length < requiredHookCount && analysis.hooksUsed.length > 0) {
+          result.violations.push({
+            file,
+            pattern: pattern.name,
+            reason: `Hook pattern divergence: uses ${analysis.hooksUsed.join(",")} but pattern expects ${structure.commonHooks.join(",")}`,
+          });
+        }
+      }
+    }
+  }
+
+  result.passed = result.violations.length === 0;
+  return result;
+}
+
 function fileMatchesGlob(filePath: string, glob: string): boolean {
   const normalized = filePath.replace(/\\/g, "/");
   const regexStr = glob

package/commands/task.ts

@@ -12,6 +12,7 @@ import { getAgentDomain, domainToScope } from "../context/domains";
 import { resolveAgent } from "../context/agent-registry";
 import { loadAgentExpertise, getAgentDescription } from "../context/agent-expertise";
 import { generateContextFile } from "../context/generator";
+import { getFullContextFilePath } from "../context/file-writer";
 import { getModelForTask } from "../context/model-profiles";
 import { getContextBudget, formatContextWarning, estimateTokens } from "../context/monitor";
 import { invalidateCache } from "../context/cache";
@@ -252,6 +253,19 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
         contextSummary = getMinimalContextForSubagent(task.id);
       }
 
+      // v10.2: Full context file path (generated alongside lean file)
+      const fullContextFile = useFileContext ? getFullContextFilePath(task.id) : "";
+
+      // v10.2: Build pending knowledge section for template
+      const pendingKnowledgeForPrompt = useFileContext
+        ? (() => {
+            const unread = getUnreadKnowledgeForTask(spec.id, task.id);
+            const critical = unread.filter((k: any) => k.severity === 'critical' && k.task_origin !== task.id);
+            if (critical.length === 0) return "";
+            return `## KNOWLEDGE PENDENTE (OBRIGATORIO)\n\nVoce DEVE reconhecer estes items antes de completar a task:\n${critical.map((k: any) => `- [ID ${k.id}] ${k.content}`).join("\n")}\n\nUse: \`codexa knowledge ack <id>\` para cada item.`;
+          })()
+        : "";
+
       // v10.0: Pre-built lean prompt for subagent (orchestrator just passes it)
       const subagentPrompt = useFileContext
         ? loadTemplate("subagent-prompt-lean", {
@@ -260,6 +274,8 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
             taskDescription: task.checkpoint || task.name,
             contextSummary: contextSummary!,
             contextFile: contextFile || "",
+            fullContextFile,
+            pendingKnowledge: pendingKnowledgeForPrompt,
             agentIdentity,
             agentExpertise: agentExpertise
               ? `\n## EXPERTISE DO AGENTE\n\n${agentExpertise}\n`
@@ -304,9 +320,21 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
       if (useFileContext) {
         // v10.0: File-based context (new default)
         output.contextFile = contextFile;
+        output.fullContextFile = fullContextFile;
         output.contextSummary = contextSummary!;
         output.contextMode = "file";
         output.subagentPrompt = subagentPrompt;
+
+        // v10.2: Fix — unreadKnowledge must be available in ALL modes
+        // Without this, file-mode subagents can't acknowledge critical knowledge,
+        // causing taskDone() to block with no way for the subagent to comply
+        const unreadKnowledge = getUnreadKnowledgeForTask(spec.id, task.id);
+        if (unreadKnowledge.length > 0) {
+          output.unreadKnowledge = unreadKnowledge.map((k: any) => ({
+            id: k.id, category: k.category, content: k.content,
+            severity: k.severity, origin_task: k.task_origin,
+          }));
+        }
       } else if (inlineContext) {
         // Backward compat: full inline
         output.context = contextText;

package/context/assembly.ts

@@ -29,6 +29,7 @@ export interface ContextData {
     libContexts: any[];
     graphDecisions: any[];
     discoveredPatterns: any[];
+    fullMode?: boolean;
 }
 
 const RETURN_PROTOCOL = `
@@ -38,7 +39,9 @@ const RETURN_PROTOCOL = `
 \`\`\`
 `;
 
-export function assembleSections(header: string, sections: ContextSection[]): string {
+export type AssemblyMode = "lean" | "full";
+
+export function assembleSections(header: string, sections: ContextSection[], mode: AssemblyMode = "lean"): string {
     // Sort by priority (lower = higher priority, kept during truncation)
     const sorted = [...sections].sort((a, b) => a.priority - b.priority);
 
@@ -49,6 +52,11 @@ export function assembleSections(header: string, sections: ContextSection[]): st
 
     output += RETURN_PROTOCOL;
 
+    // v10.2: Full mode — no truncation, no caps. Used for the full reference file.
+    if (mode === "full") {
+        return output;
+    }
+
     // v10.0: Progressive truncation — halve sections before dropping them entirely
     if (output.length > MAX_CONTEXT_SIZE) {
         return truncateWithBudget(header, sorted, MAX_CONTEXT_SIZE);

package/context/file-writer.ts

@@ -25,10 +25,21 @@ export function writeContextFile(taskId: number, content: string): string {
   return resolve(filePath);
 }
 
+export function writeFullContextFile(taskId: number, content: string): string {
+  const dir = ensureContextDir();
+  const filePath = join(dir, `task-${taskId}-full.md`);
+  Bun.write(filePath, content);
+  return resolve(filePath);
+}
+
 export function getContextFilePath(taskId: number): string {
   return resolve(process.cwd(), CONTEXT_DIR, `task-${taskId}.md`);
 }
 
+export function getFullContextFilePath(taskId: number): string {
+  return resolve(process.cwd(), CONTEXT_DIR, `task-${taskId}-full.md`);
+}
+
 export function cleanupContextFiles(specId: string): void {
   const dir = resolve(process.cwd(), CONTEXT_DIR);
   if (!existsSync(dir)) return;

package/context/generator.ts

@@ -2,11 +2,11 @@ import { getDb } from "../db/connection";
 import { initSchema, getPatternsForFiles, getRelatedDecisions, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { getKnowledgeForTask } from "../commands/knowledge";
 import type { ContextSection, ContextData } from "./assembly";
-import { assembleSections } from "./assembly";
+import { assembleSections, type AssemblyMode } from "./assembly";
 import { getAgentDomain, adjustSectionPriorities, domainToScope } from "./domains";
 import { filterRelevantDecisions, filterRelevantStandards } from "./scoring";
 import { computeContextHash, getCachedContextPath, setCachedContext } from "./cache";
-import { writeContextFile } from "./file-writer";
+import { writeContextFile, writeFullContextFile } from "./file-writer";
 import {
     buildProductSection,
     buildArchitectureSection,
@@ -114,7 +114,7 @@ export function getMinimalContextForSubagent(taskId: number): string {
 // CONTEXT BUILDER (v9.0 — decomposed from v8.1 monolith)
 // ═══════════════════════════════════════════════════════════════
 
-function fetchContextData(taskId: number): ContextData | null {
+function fetchContextData(taskId: number, fullMode: boolean = false): ContextData | null {
     const db = getDb();
 
     const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
@@ -131,11 +131,12 @@ function fetchContextData(taskId: number): ContextData | null {
     const taskFiles = task.files ? JSON.parse(task.files) : [];
     const domain = domainToScope(getAgentDomain(task.agent));
 
-    // Decisoes relevantes (max 8, priorizando as que mencionam arquivos da task)
+    // Decisoes relevantes (v10.2: fullMode removes limits)
+    const decisionLimit = fullMode ? 200 : 30;
     const allDecisions = db
-        .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active' ORDER BY created_at DESC LIMIT 30")
-        .all(task.spec_id) as any[];
-    const decisions = filterRelevantDecisions(allDecisions, taskFiles, 8);
+        .query(`SELECT * FROM decisions WHERE spec_id = ? AND status = 'active' ORDER BY created_at DESC LIMIT ?`)
+        .all(task.spec_id, decisionLimit) as any[];
+    const decisions = fullMode ? allDecisions : filterRelevantDecisions(allDecisions, taskFiles, 8);
 
     // Standards required + recommended que se aplicam aos arquivos
     const standards = db
@@ -147,13 +148,13 @@ function fetchContextData(taskId: number): ContextData | null {
         .all(domain) as any[];
     const relevantStandards = filterRelevantStandards(standards, taskFiles);
 
-    // Knowledge com caps e indicadores de truncamento
+    // Knowledge com caps e indicadores de truncamento (v10.2: fullMode removes caps)
     const allKnowledge = getKnowledgeForTask(task.spec_id, taskId);
     const allCriticalKnowledge = allKnowledge.filter((k: any) => k.severity === 'critical' || k.severity === 'warning');
-    const criticalKnowledge = allCriticalKnowledge.slice(0, 20);
+    const criticalKnowledge = fullMode ? allCriticalKnowledge : allCriticalKnowledge.slice(0, 20);
     const truncatedCritical = allCriticalKnowledge.length - criticalKnowledge.length;
     const allInfoKnowledge = allKnowledge.filter((k: any) => k.severity === 'info');
-    const infoKnowledge = allInfoKnowledge.slice(0, 10);
+    const infoKnowledge = fullMode ? allInfoKnowledge : allInfoKnowledge.slice(0, 10);
     const truncatedInfo = allInfoKnowledge.length - infoKnowledge.length;
 
     const productContext = db.query("SELECT * FROM product_context WHERE id = 'default'").get() as any;
@@ -239,10 +240,14 @@ function fetchContextData(taskId: number): ContextData | null {
 
 // ── Main Entry Point ──────────────────────────────────────────
 
-function buildFullContext(taskId: number): { content: string; data: ContextData } | null {
-    const data = fetchContextData(taskId);
+function buildContext(taskId: number, mode: AssemblyMode = "lean"): { content: string; data: ContextData } | null {
+    const isFullMode = mode === "full";
+    const data = fetchContextData(taskId, isFullMode);
     if (!data) return null;
 
+    // Pass fullMode flag so section builders remove caps
+    data.fullMode = isFullMode;
+
     const header = `## CONTEXTO (Task #${data.task.number})
 
 **Feature:** ${data.spec.name}
@@ -269,7 +274,12 @@ function buildFullContext(taskId: number): { content: string; data: ContextData
     const agentDomain = getAgentDomain(data.task.agent);
     const sections = adjustSectionPriorities(allSections, agentDomain);
 
-    return { content: assembleSections(header, sections), data };
+    return { content: assembleSections(header, sections, mode), data };
+}
+
+// Backward compat wrapper
+function buildFullContext(taskId: number): { content: string; data: ContextData } | null {
+    return buildContext(taskId, "lean");
 }
 
 export function getContextForSubagent(taskId: number): string {
@@ -280,6 +290,11 @@ export function getContextForSubagent(taskId: number): string {
 
 // ── v10.0: File-Based Context ─────────────────────────────────
 
+export interface GeneratedContextFiles {
+    leanPath: string;
+    fullPath: string;
+}
+
 export function generateContextFile(taskId: number): string {
     initSchema();
 
@@ -292,12 +307,18 @@ export function generateContextFile(taskId: number): string {
     const cached = getCachedContextPath(hash);
     if (cached) return cached;
 
-    // Generate fresh context
-    const result = buildFullContext(taskId);
-    if (!result) return "";
+    // Generate lean context (16KB max, truncated)
+    const leanResult = buildFullContext(taskId);
+    if (!leanResult) return "";
+
+    // v10.2: Generate full context (no truncation, no caps)
+    const fullResult = buildContext(taskId, "full");
+    if (fullResult) {
+        writeFullContextFile(taskId, fullResult.content);
+    }
 
-    // Write to file and cache
-    const filePath = writeContextFile(taskId, result.content);
+    // Write lean file and cache
+    const filePath = writeContextFile(taskId, leanResult.content);
     setCachedContext(hash, filePath, task.spec_id);
 
     return filePath;

package/context/sections.ts

@@ -8,21 +8,43 @@ import { findReferenceFiles } from "./references";
 export function buildProductSection(data: ContextData): ContextSection | null {
     if (!data.productContext) return null;
 
+    const p = data.productContext;
     let content = `
 ### PRODUTO
-- **Problema:** ${data.productContext.problem || "N/A"}
-- **Usuarios:** ${data.productContext.target_users || "N/A"}`;
-    if (data.productContext.constraints) {
+- **Problema:** ${p.problem || "N/A"}`;
+
+    if (p.solution) {
+        content += `\n- **Solucao:** ${p.solution}`;
+    }
+
+    content += `\n- **Usuarios:** ${p.target_users || "N/A"}`;
+
+    if (p.value_proposition) {
+        content += `\n- **Proposta de Valor:** ${p.value_proposition}`;
+    }
+
+    if (p.success_metrics) {
+        content += `\n- **Metricas de Sucesso:** ${p.success_metrics}`;
+    }
+
+    if (p.constraints) {
         try {
-            const constraints = JSON.parse(data.productContext.constraints);
+            const constraints = JSON.parse(p.constraints);
             if (constraints.length > 0) {
-                content += `\n- **Restricoes:** ${constraints.slice(0, 3).join("; ")}${constraints.length > 3 ? ` [+${constraints.length - 3} mais]` : ''}`;
+                content += `\n- **Restricoes:** ${constraints.join("; ")}`;
             }
         } catch { /* ignore parse errors */ }
     }
+
+    if (p.out_of_scope) {
+        content += `\n- **Fora de Escopo:** ${p.out_of_scope}`;
+    }
+
     content += "\n";
 
-    return { name: "PRODUTO", content, priority: 7 };
+    // v10.2: Product context is small (~500-2000 bytes) but high-impact.
+    // Priority 1 ensures it is NEVER truncated.
+    return { name: "PRODUTO", content, priority: 1 };
 }
 
 export function buildArchitectureSection(data: ContextData): ContextSection | null {
@@ -92,10 +114,12 @@ export function buildStandardsSection(data: ContextData): ContextSection {
 }
 
 export function buildDecisionsSection(data: ContextData): ContextSection {
-    const truncatedDecisions = data.allDecisions.length - data.decisions.length;
+    // v10.2: In full mode, show ALL decisions (no cap at 8)
+    const decisionsToShow = data.fullMode ? data.allDecisions : data.decisions;
+    const truncatedDecisions = data.allDecisions.length - decisionsToShow.length;
     const content = `
-### DECISOES (${data.decisions.length}${truncatedDecisions > 0 ? ` [+${truncatedDecisions} mais - use: decisions list]` : ''})
-${data.decisions.length > 0 ? data.decisions.map((d) => `- **${d.title}**: ${d.decision}`).join("\n") : "Nenhuma"}
+### DECISOES (${decisionsToShow.length}${truncatedDecisions > 0 ? ` [+${truncatedDecisions} mais - use: decisions list]` : ''})
+${decisionsToShow.length > 0 ? decisionsToShow.map((d: any) => `- **${d.title}**: ${d.decision}`).join("\n") : "Nenhuma"}
 `;
     return { name: "DECISOES", content, priority: 4 };
 }
@@ -146,10 +170,12 @@ ${data.patterns.map((p: any) => {
     }
 
     if (data.discoveredPatterns.length > 0) {
-        const patternsToShow = data.discoveredPatterns.slice(-10);
+        // v10.2: Full mode shows ALL discovered patterns
+        const patternsToShow = data.fullMode ? data.discoveredPatterns : data.discoveredPatterns.slice(-10);
+        const truncated = data.discoveredPatterns.length - patternsToShow.length;
         content += `
 ### PATTERNS DESCOBERTOS (${data.discoveredPatterns.length})
-${data.discoveredPatterns.length > 10 ? `[mostrando ultimos 10 de ${data.discoveredPatterns.length}]\n` : ''}${patternsToShow.map((p: any) => `- ${p.pattern}${p.source_task ? ` (Task #${p.source_task})` : ""}`).join("\n")}
+${truncated > 0 ? `[mostrando ultimos 10 de ${data.discoveredPatterns.length}]\n` : ''}${patternsToShow.map((p: any) => `- ${p.pattern}${p.source_task ? ` (Task #${p.source_task})` : ""}`).join("\n")}
 `;
     }
 
@@ -165,7 +191,9 @@ export function buildUtilitiesSection(data: ContextData): ContextSection | null
         }).filter(Boolean))];
 
         const agentScope = domainToScope(getAgentDomain(data.task.agent)) || undefined;
-        let relevantUtilities = getUtilitiesForContext(taskDirs, undefined, 15);
+        // v10.2: Full mode fetches all utilities
+        const utilLimit = data.fullMode ? 200 : 15;
+        let relevantUtilities = getUtilitiesForContext(taskDirs, undefined, utilLimit);
 
         if (relevantUtilities.length < 5 && agentScope) {
             const scopeUtils = getUtilitiesForContext([], agentScope, 15);
@@ -174,7 +202,7 @@ export function buildUtilitiesSection(data: ContextData): ContextSection | null
                 if (!existingKeys.has(`${u.file_path}:${u.utility_name}`)) {
                     relevantUtilities.push(u);
                 }
-                if (relevantUtilities.length >= 15) break;
+                if (relevantUtilities.length >= utilLimit) break;
             }
         }
 
@@ -215,10 +243,12 @@ export function buildStackSection(data: ContextData): ContextSection | null {
     if (data.project) {
         const stack = JSON.parse(data.project.stack);
         const allStackEntries = Object.entries(stack);
-        const mainStack = allStackEntries.slice(0, 6);
+        // v10.2: Full mode shows all stack entries
+        const mainStack = data.fullMode ? allStackEntries : allStackEntries.slice(0, 6);
+        const truncatedStack = allStackEntries.length - mainStack.length;
         content += `
 ### STACK
-${mainStack.map(([k, v]) => `${k}: ${v}`).join(" | ")}${allStackEntries.length > 6 ? ` [+${allStackEntries.length - 6} mais]` : ''}
+${mainStack.map(([k, v]) => `${k}: ${v}`).join(" | ")}${truncatedStack > 0 ? ` [+${truncatedStack} mais]` : ''}
 `;
     }
 

package/db/schema.ts

@@ -544,6 +544,46 @@ export function runMigrations(): void {
 // Exportar MIGRATIONS para testes
 export { MIGRATIONS };
 
+// ═══════════════════════════════════════════════════════════════
+// v10.2: Transacao Atomica Helper
+// Wrapa qualquer operacao em BEGIN IMMEDIATE / COMMIT com
+// rollback automatico em caso de erro.
+// BEGIN IMMEDIATE garante lock exclusivo para escrita desde o
+// inicio, evitando deadlocks em WAL mode.
+// ═══════════════════════════════════════════════════════════════
+
+const MAX_BUSY_RETRIES = 3;
+const BUSY_RETRY_BASE_MS = 50;
+
+export function runInTransaction<T>(fn: () => T): T {
+  const db = getDb();
+  let retries = MAX_BUSY_RETRIES;
+
+  while (retries > 0) {
+    try {
+      db.exec("BEGIN IMMEDIATE");
+      break;
+    } catch (e: any) {
+      if (e.message?.includes("SQLITE_BUSY") && retries > 1) {
+        retries--;
+        const delay = BUSY_RETRY_BASE_MS * (MAX_BUSY_RETRIES - retries);
+        Bun.sleepSync(delay);
+        continue;
+      }
+      throw e;
+    }
+  }
+
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (e) {
+    try { db.exec("ROLLBACK"); } catch { /* already rolled back */ }
+    throw e;
+  }
+}
+
 // Gera proximo ID de decisao para um spec
 // Usa timestamp + random hash para eliminar race conditions entre tasks paralelas
 export function getNextDecisionId(specId: string): string {

package/gates/validator.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, statSync } from "fs";
 import { extname } from "path";
 import { validateAgainstStandards, printValidationResult } from "./standards-validator";
 import { runTypecheck, printTypecheckResult } from "./typecheck-validator";
-import { extractUtilitiesFromFile, inferScopeFromPath } from "../commands/patterns";
+import { extractUtilitiesFromFile, inferScopeFromPath, validatePatternCompliance } from "../commands/patterns";
 import { findDuplicateUtilities } from "../db/schema";
 import { GateError, RecoverySuggestion } from "../errors";
 import { resolveSpecOrNull } from "../commands/spec-resolver";
@@ -86,6 +86,11 @@ const GATES: Record<string, GateCheck[]> = {
       message: "Duplicacao de utilities detectada (DRY)",
       resolution: "Importe do arquivo existente ou use --force --force-reason para bypass",
     },
+    {
+      check: "pattern-compliance",
+      message: "Codigo diverge dos patterns do projeto",
+      resolution: "Siga os patterns detectados ou use --force --force-reason para bypass",
+    },
     {
       check: "reasoning-provided",
       message: "Reasoning obrigatorio ausente no retorno do subagent",
@@ -171,6 +176,15 @@ const RECOVERY_STRATEGIES: Record<string, (details?: string) => RecoverySuggesti
     ],
     command: "codexa decisions",
   }),
+  "pattern-compliance": (details) => ({
+    diagnostic: `Divergencias de pattern detectadas:\n${details || "Detalhes nao disponiveis"}`,
+    steps: [
+      "Revise os patterns com: codexa context detail patterns",
+      "Ajuste o codigo para seguir os patterns do projeto",
+      "Ou use --force --force-reason 'motivo' para bypass (auditado no review)",
+    ],
+    command: "codexa context detail patterns",
+  }),
   "reasoning-provided": () => ({
     diagnostic: "Subagent retornou sem reasoning.approach adequado",
     steps: [
@@ -519,6 +533,28 @@ function executeCheck(check: string, context: any): { passed: boolean; details?:
       return { passed: true };
     }
 
+    case "pattern-compliance": {
+      // v10.2: Gate 4.7 — validate code follows project patterns
+      if (context.force) {
+        logGateBypass(context.taskId, "pattern-compliance", context.forceReason);
+        return { passed: true };
+      }
+
+      if (!context.files || context.files.length === 0) return { passed: true };
+
+      const patternResult = validatePatternCompliance(context.files);
+      if (!patternResult.passed && patternResult.violations.length > 0) {
+        // v10.2: Start in warning mode (don't block, just warn)
+        // Change to `return { passed: false, ... }` after validation in real projects
+        console.warn("\n[PATTERN] Divergencias de pattern detectadas (aviso, nao bloqueante):");
+        for (const v of patternResult.violations) {
+          console.warn(`  - ${v.file}: ${v.reason} (pattern: ${v.pattern})`);
+        }
+        console.warn();
+      }
+      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.25",
+  "version": "9.0.26",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {

package/protocol/process-return.ts

@@ -11,7 +11,7 @@
 
 import { getDb } from "../db/connection";
 import { SubagentReturn, Knowledge } from "./subagent-protocol";
-import { addReasoning, addGraphRelation, upsertUtility, getNextDecisionId } from "../db/schema";
+import { addReasoning, addGraphRelation, upsertUtility, getNextDecisionId, runInTransaction } from "../db/schema";
 import { extractUtilitiesFromFile, inferScopeFromPath } from "../commands/patterns";
 import { detectConflicts } from "../commands/decide";
 
@@ -37,6 +37,17 @@ export function processSubagentReturn(
   taskId: number,
   taskNumber: number,
   data: SubagentReturn
+): ProcessResult {
+  // v10.2: Wrap entire processing in atomic transaction
+  // Prevents race conditions in parallel tasks (pattern storage, knowledge dedup)
+  return runInTransaction(() => processSubagentReturnInner(specId, taskId, taskNumber, data));
+}
+
+function processSubagentReturnInner(
+  specId: string,
+  taskId: number,
+  taskNumber: number,
+  data: SubagentReturn
 ): ProcessResult {
   const db = getDb();
   const now = new Date().toISOString();

package/templates/subagent-prompt-lean.md

@@ -7,17 +7,25 @@
 
 {{contextSummary}}
 
-## CONTEXTO COMPLETO
+## CONTEXTO
 
-Leia o arquivo de contexto completo com Read tool (apenas secoes relevantes para sua task):
+**Contexto resumido (standards, alertas, decisoes):**
   {{contextFile}}
 
+**Contexto COMPLETO (todos os patterns, utilities, decisions, knowledge SEM truncacao):**
+  {{fullContextFile}}
+
+Leia o arquivo de contexto completo quando precisar de detalhes sobre patterns, utilities, stack ou discoveries que nao aparecem no resumido.
+
+{{pendingKnowledge}}
+
 ## EXECUTE AGORA
 
-1. Read o arquivo de contexto acima (secoes que precisar)
-2. Read arquivos existentes que precisa modificar
-3. Edit/Write para criar/modificar os arquivos listados
-4. Retorne JSON:
+1. Read o arquivo de contexto resumido
+2. Se precisar de mais detalhes, Read o arquivo de contexto completo (secoes relevantes)
+3. Read arquivos existentes que precisa modificar
+4. Edit/Write para criar/modificar os arquivos listados
+5. Retorne JSON:
 
 ```json
 {"status": "completed", "summary": "...", "files_created": [], "files_modified": [], "reasoning": {"approach": "como abordou (min 20 chars)", "challenges": [], "recommendations": "para proximas tasks"}, "knowledge_to_broadcast": [], "decisions_made": []}

package/workflow.ts

@@ -787,6 +787,32 @@ discoverCmd
     discoverRefreshPatterns();
   });
 
+discoverCmd
+  .command("detect-semantic")
+  .description("Detecta patterns semanticos via grepai (error handling, data fetching, etc.)")
+  .option("--json", "Saida em JSON")
+  .action((options) => {
+    const { detectSemanticPatterns, saveSemanticPatterns, isGrepaiAvailable } = require("./commands/patterns");
+    if (!isGrepaiAvailable()) {
+      console.error("[!] grepai nao disponivel. Instale com: pip install grepai");
+      process.exit(1);
+    }
+    const patterns = detectSemanticPatterns();
+    if (patterns.length === 0) {
+      console.log("\nNenhum pattern semantico detectado.");
+      return;
+    }
+    const saved = saveSemanticPatterns(patterns);
+    if (options.json) {
+      console.log(JSON.stringify({ detected: patterns.length, saved }));
+    } else {
+      console.log(`\nPatterns semanticos detectados: ${patterns.length}, salvos: ${saved}`);
+      for (const p of patterns) {
+        console.log(`  - ${p.name} (${p.scope}, confidence: ${p.confidence.toFixed(2)}, ${p.files.length} files)`);
+      }
+    }
+  });
+
 discoverCmd
   .command("export-patterns", { hidden: true })
   .description("Regenera arquivo patterns.md")