wegho-agentes 7.0.3 → 7.0.6

package/.agents/orchestrator.ts

@@ -1,817 +1,375 @@
-/**
- * Intelligent Orchestrator - Agente de Auditoria Orquestrador
- * 
- * Responsabilidades:
- * - Analisar tarefa e selecionar melhores agentes baseado em memória
- * - Distribuir subtarefas para agentes especializados
- * - Executar 6 passos obrigatórios com aprendizado
- * - Coletar feedback e registrar resultados
- * - Dar decisão final GO/NO-GO
- */
-
-import { FrontEndAgent } from './core/frontend-agent.js';
-import { SecurityAgent } from './core/security-agent.js';
-import { ArchitectureAgent } from './core/architecture-agent.js';
-import { QualityAgent } from './core/quality-agent.js';
-import { DocumentationAgent } from './core/documentation-agent.js';
-import { InventoryAgent } from './core/inventory-agent.js';
-
-// Domain Agents
-import { CMSAgent } from './domains/news/cms-agent.js';
-import { SEOAgent } from './domains/news/seo-agent.js';
-import { ProductionControlAgent } from './domains/production/production-control-agent.js';
-import { RouteAgent } from './domains/logistics/route-agent.js';
-
-import { TaskAnalyzerAgent, TaskAnalysis, AgentAssignment } from './task-analyzer-agent.js';
-import { MemorySystem } from './core/memory-system.js';
-import { FeedbackCollector, UserFeedback } from './core/feedback-collector.js';
-import { AgentConfig, DEFAULT_CONFIG } from './config.js';
-import { ProjectContext } from './context-loader.js';
+import { FrontEndAgent } from './core/frontend-agent.js';
+import { SecurityAgent } from './core/security-agent.js';
+import { ArchitectureAgent } from './core/architecture-agent.js';
+import { QualityAgent } from './core/quality-agent.js';
+import { DocumentationAgent } from './core/documentation-agent.js';
+import { CMSAgent } from './domains/news/cms-agent.js';
+import { SEOAgent } from './domains/news/seo-agent.js';
+import { ProductionControlAgent } from './domains/production/production-control-agent.js';
+import { RouteAgent } from './domains/logistics/route-agent.js';
+import { TaskAnalyzerAgent, TaskAnalysis, AgentAssignment } from './task-analyzer-agent.js';
+import { AgentConfig, DEFAULT_CONFIG } from './config.js';
+import { ProjectContext } from './context-loader.js';
 import { BaseAgent, TaskContext, TaskResult } from './core/base-agent.js';
 import { RetryUtility } from './core/retry-utility.js';
 import { AgentParallelizer } from './core/agent-parallelizer.js';
 import { PerformanceTracker } from './core/performance-tracker.js';
 import { WorkflowValidator } from './core/workflow-validator.js';
-import { PlanningAgent, ImplementationPlan } from './core/planning-agent.js';
-import { CheckpointManager } from './core/checkpoint-manager.js';
-import { FileGenerator } from './core/file-generator.js';
-import { ReportGenerator, ExecutionReport } from './core/report-generator.js';
-import { NextJSAgent } from './core/nextjs-agent.js';
-import { UIUXAgent } from './core/uiux-agent.js';
-import { BackendAgent } from './core/backend-agent.js';
-import { DatabaseAgent } from './core/database-agent.js';
-import { AIAgentsAgent } from './core/ai-agents-agent.js';
-import { RAGAgent } from './core/rag-agent.js';
-import { PentestAgent } from './core/pentest-agent.js';
-import { DevOpsAgent } from './core/devops-agent.js';
-import { CloudAgent } from './core/cloud-agent.js';
-import { TestingAgent } from './core/testing-agent.js';
+import { PlanningAgent, ImplementationPlan } from './core/planning-agent.js';
+import { CheckpointManager } from './core/checkpoint-manager.js';
+import { FileGenerator } from './core/file-generator.js';
+import { ReportGenerator } from './core/report-generator.js';
+import { NextJSAgent } from './core/nextjs-agent.js';
+import { UIUXAgent } from './core/uiux-agent.js';
+import { BackendAgent } from './core/backend-agent.js';
+import { DatabaseAgent } from './core/database-agent.js';
+import { AIAgentsAgent } from './core/ai-agents-agent.js';
+import { RAGAgent } from './core/rag-agent.js';
+import { PentestAgent } from './core/pentest-agent.js';
+import { DevOpsAgent } from './core/devops-agent.js';
+import { CloudAgent } from './core/cloud-agent.js';
+import { TestingAgent } from './core/testing-agent.js';
 import { CROAgent } from './core/cro-agent.js';
 import { AutomationAgent } from './core/automation-agent.js';
 import { BuildManager } from './core/build-manager.js';
 import { UIDataMapAgent } from './core/ui-data-map-agent.js';
 import { StackBoundaryAgent } from './core/stack-boundary-agent.js';
-
-export interface AgentReport {
-    agentName: string;
-    stepNumber: number;
-    status: 'success' | 'warning' | 'error';
-    summary: string;
-    details: string;
-    blockers?: string[];
-}
-
-export interface FinalReport {
-    taskDescription: string;
-    overallSuccess: boolean;
-    agentReports: {
-        agentName: string;
-        stepNumber: number;
-        status: string;
-        summary: string;
-        details?: string;
-        blockers?: string[];
-    }[];
-    buildNumber?: number; // 🆕 Build criado (se houver)
-}
-export interface ExecutionResult {
-    success: boolean;
-    status: 'GO' | 'NO-GO';
-    reports: AgentReport[];
-    blockers: string[];
-    taskId: string;
-}
-
-export class IntelligentOrchestrator {
-    private config: AgentConfig;
-    private taskAnalyzer: TaskAnalyzerAgent;
-    private memory: MemorySystem;
-    private feedbackCollector: FeedbackCollector;
-    private context: ProjectContext;
-    private performanceTracker: PerformanceTracker;
-
-    // Core Agents
-    private frontendAgent: FrontEndAgent;
-    private securityAgent: SecurityAgent;
-    private architectureAgent: ArchitectureAgent;
-    private qualityAgent: QualityAgent;
-    private documentationAgent: DocumentationAgent;
-    private inventoryAgent: InventoryAgent;
-
-    // Domain Agents
-    private cmsAgent: CMSAgent;
-    private seoAgent: SEOAgent;
-    private productionControlAgent: ProductionControlAgent;
-    private routeAgent: RouteAgent;
-
-    // New: Planning, Checkpoint, File Generation, and Reporting
-    private planningAgent: PlanningAgent;
-    private checkpointManager: CheckpointManager;
-    private fileGenerator: FileGenerator;
-    private reportGenerator: ReportGenerator;
-
-    // New: 12 Specialized Agents
-    private nextjsAgent: NextJSAgent;
-    private uiuxAgent: UIUXAgent;
-    private backendAgent: BackendAgent;
-    private databaseAgent: DatabaseAgent;
-    private aiAgentsAgent: AIAgentsAgent;
-    private ragAgent: RAGAgent;
-    private pentestAgent: PentestAgent;
-    private devopsAgent: DevOpsAgent;
-    private cloudAgent: CloudAgent;
-    private testingAgent: TestingAgent;
+
+export interface AgentReport {
+    agentName: string;
+    stepNumber: number;
+    status: 'success' | 'warning' | 'error';
+    summary: string;
+    details: string;
+    blockers?: string[];
+}
+
+export interface ExecutionResult {
+    success: boolean;
+    status: 'GO' | 'NO-GO';
+    reports: AgentReport[];
+    blockers: string[];
+    taskId: string;
+}
+
+export class IntelligentOrchestrator {
+    private config: AgentConfig;
+    private taskAnalyzer: TaskAnalyzerAgent;
+    private context: ProjectContext;
+    private performanceTracker: PerformanceTracker;
+    private frontendAgent: FrontEndAgent;
+    private securityAgent: SecurityAgent;
+    private architectureAgent: ArchitectureAgent;
+    private qualityAgent: QualityAgent;
+    private documentationAgent: DocumentationAgent;
+    private cmsAgent: CMSAgent;
+    private seoAgent: SEOAgent;
+    private productionControlAgent: ProductionControlAgent;
+    private routeAgent: RouteAgent;
+    private planningAgent: PlanningAgent;
+    private checkpointManager: CheckpointManager;
+    private fileGenerator: FileGenerator;
+    private reportGenerator: ReportGenerator;
+    private nextjsAgent: NextJSAgent;
+    private uiuxAgent: UIUXAgent;
+    private backendAgent: BackendAgent;
+    private databaseAgent: DatabaseAgent;
+    private aiAgentsAgent: AIAgentsAgent;
+    private ragAgent: RAGAgent;
+    private pentestAgent: PentestAgent;
+    private devopsAgent: DevOpsAgent;
+    private cloudAgent: CloudAgent;
+    private testingAgent: TestingAgent;
     private croAgent: CROAgent;
     private automationAgent: AutomationAgent;
     private uiDataMapAgent: UIDataMapAgent;
     private stackBoundaryAgent: StackBoundaryAgent;
     private buildManager: BuildManager;
-
-    constructor(context: ProjectContext, config: AgentConfig = DEFAULT_CONFIG) {
-        this.context = context;
-        this.config = config;
-        this.taskAnalyzer = new TaskAnalyzerAgent();
-        this.memory = new MemorySystem(config.memoryPath, config.maxMemoryEntries);
-        this.feedbackCollector = new FeedbackCollector(config.memoryPath);
-        this.performanceTracker = new PerformanceTracker();
-
-        // Inicializar todos os agentes com memória
-        this.frontendAgent = new FrontEndAgent(config.memoryPath);
-        this.securityAgent = new SecurityAgent(config.memoryPath);
-        this.architectureAgent = new ArchitectureAgent(config.memoryPath);
-        this.qualityAgent = new QualityAgent(config.memoryPath);
-        this.documentationAgent = new DocumentationAgent(config.memoryPath);
-        this.inventoryAgent = new InventoryAgent(process.cwd());
-
-        // Inicializar agentes de domínio
-        this.cmsAgent = new CMSAgent(config.memoryPath);
-        this.seoAgent = new SEOAgent(config.memoryPath);
-        this.productionControlAgent = new ProductionControlAgent(config.memoryPath);
-        this.routeAgent = new RouteAgent(config.memoryPath);
-
-        // Inicializar planning, checkpoint, file generation e reporting
-        const projectRoot = process.cwd();
-        this.planningAgent = new PlanningAgent(config.memoryPath, projectRoot);
-        this.checkpointManager = new CheckpointManager(projectRoot);
-        this.fileGenerator = new FileGenerator(projectRoot);
-        this.reportGenerator = new ReportGenerator();
-
-        // Inicializar 12 novos agentes especializados
-        this.nextjsAgent = new NextJSAgent(config.memoryPath);
-        this.uiuxAgent = new UIUXAgent(config.memoryPath);
-        this.backendAgent = new BackendAgent(config.memoryPath);
-        this.databaseAgent = new DatabaseAgent(config.memoryPath);
-        this.aiAgentsAgent = new AIAgentsAgent(config.memoryPath);
-        this.ragAgent = new RAGAgent(config.memoryPath);
-        this.pentestAgent = new PentestAgent(config.memoryPath);
-        this.devopsAgent = new DevOpsAgent(config.memoryPath);
-        this.cloudAgent = new CloudAgent(config.memoryPath);
-        this.testingAgent = new TestingAgent(config.memoryPath);
-        this.croAgent = new CROAgent(config.memoryPath);
-        this.automationAgent = new AutomationAgent(config.memoryPath);
-        this.uiDataMapAgent = new UIDataMapAgent(config.memoryPath);
-        this.stackBoundaryAgent = new StackBoundaryAgent(config.memoryPath);
-
-        // Inicializar Build Manager
-        this.buildManager = new BuildManager(projectRoot);
-    }
-
-    /**
-     * Orquestra uma tarefa completa com aprendizado
-     */
-    async orchestrateTask(taskDescription: string): Promise<ExecutionResult> {
-        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-        console.log('🎯 ORQUESTRADOR INTELIGENTE');
-        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-        console.log(`🧮 Tokens estimados (tarefa): ${this.estimateTokens(taskDescription)}\n`);
-
-        const taskId = this.generateTaskId();
-        const startTime = Date.now();
-        let checkpointId: string | null = null;
-        let implementationPlan: ImplementationPlan | null = null;
-        const blockers: string[] = [];
-
-        try {
-            // 1. Analisar tarefa
-            console.log('📊 Fase 1: Análise da Tarefa\n');
-            const analysis = await this.taskAnalyzer.analyzeTask(taskDescription, this.config);
-
-            // 2. NOVO: Criar plano de implementação
-            console.log('\n🏗️  Fase 2: Planejamento Automático\n');
-            implementationPlan = await this.planningAgent.createImplementationPlan(taskDescription);
-
-            // 3. NOVO: Criar checkpoint antes de implementar
-            console.log('\n💾 Fase 3: Criando Checkpoint\n');
-            checkpointId = await this.checkpointManager.createCheckpoint(
-                `pre-implementation-${taskId}`,
-                implementationPlan.files.create.map(f => f.path)
-            );
-
-            // 4. NOVO: Implementar arquivos do plano
-            console.log('\n⚙️  Fase 4: Implementação Automática\n');
-            await this.implementPlan(implementationPlan);
-
-            // 5. NOVO: Validação automática
-            console.log('\n🔍 Fase 5: Validação Automática\n');
-            const validationResult = await this.runValidation();
-
-            if (!validationResult.passed) {
-                console.log('⚠️  Validação falhou, mas prosseguindo para auditoria completa...');
-                validationResult.errors.forEach(err => blockers.push(err));
-                // Não lançar erro para permitir que os agentes de auditoria (Fase 6/7) rodem
-            }
-
-            // 6. Selecionar melhores agentes baseado em memória (para auditoria)
-            console.log('\n🤖 Fase 6: Auditoria com Agentes\n');
-            const selectedAgents = await this.selectBestAgents(analysis);
-
-            // 7. Executar agentes para validação adicional (EM PARALELO)
-            console.log('\n⚙️  Fase 7: Validação por Agentes\n');
-
-            // Agrupar agentes para execução paralela
-            const agentGroups = AgentParallelizer.groupAgents(selectedAgents);
-            const timeEstimate = AgentParallelizer.estimateTimeReduction(selectedAgents);
-
-            console.log(`📊 Agentes agrupados em ${agentGroups.length} grupo(s) paralelo(s)`);
-            console.log(`⏱️  Redução estimada de tempo: ${timeEstimate.reduction}% (${timeEstimate.sequential}s → ${timeEstimate.parallel}s)\n`);
-
-            const reports: AgentReport[] = [];
-            let success = true;
-
-            // VERIFICAÇÃO ANTI-DUPLICAÇÃO PROATIVA
-            await this.checkDuplicationBeforeExecution(taskDescription);
-
-            // Executar cada grupo em paralelo
-            for (let i = 0; i < agentGroups.length; i++) {
-                const group = agentGroups[i];
-
-                if (group.length === 1) {
-                    console.log(`\n🔹 Grupo ${i + 1}: Executando ${group[0].agentName}`);
-                } else {
-                    console.log(`\n🔸 Grupo ${i + 1}: Executando ${group.length} agentes em paralelo:`);
-                    group.forEach(a => console.log(`   - ${a.agentName}`));
-                }
-
-                // Executar agentes do grupo em paralelo
-                const groupReports = await Promise.all(
-                    group.map(assignment => this.executeWithAgent(assignment, analysis))
-                );
-
-                // 🆕 CRIAR BUILD se houve mudanças bem-sucedidas
-                const successfulAgents = groupReports.filter(r => r.status === 'success');
-                if (successfulAgents.length > 0 && implementationPlan) {
-                    const allFiles = [
-                        ...implementationPlan.files.create.map(f => f.path),
-                        ...implementationPlan.files.modify.map(f => f.path)
-                    ];
-
-                    if (allFiles.length > 0) {
-                        try {
-                            const buildNumber = await this.buildManager.createBuild(
-                                allFiles,
-                                `orchestrator (${successfulAgents.map(a => a.agentName).join(', ')})`,
-                                true,
-                                taskDescription
-                            );
-                            console.log(`\n📦 Build ${buildNumber} criado automaticamente`);
-                            console.log(`   Arquivos rastreados: ${allFiles.length}`);
-                            console.log(`   Agentes envolvidos: ${successfulAgents.map(a => a.agentName).join(', ')}`);
-                        } catch (error) {
-                            console.warn('⚠️  Erro ao criar build:', error);
-                        }
-                    }
-                }
-
-                reports.push(...groupReports);
-
-                // Verificar se houve erro crítico
-                const hasError = groupReports.some(r => r.status === 'error');
-                if (hasError) {
-                    success = false;
-                    groupReports.forEach(r => {
-                        if (r.blockers) blockers.push(...r.blockers);
-                    });
-                    console.log('\n❌ Erro crítico detectado, parando execução');
-                    break; // Para na primeira falha crítica
-                }
-            }
-
-            // 4. Gerar relatório de performance
-            console.log('\n📊 Relatório de Performance\n');
-            const perfReport = this.performanceTracker.generateReport(taskId);
-
-            console.log(`⏱️  Duração total: ${(perfReport.totalDuration / 1000).toFixed(2)}s`);
-            console.log(`🤖 Agentes executados: ${perfReport.agentMetrics.size}`);
-
-            if (perfReport.bottlenecks.length > 0) {
-                console.log(`\n⚠️  Bottlenecks identificados:`);
-                perfReport.bottlenecks.forEach(name => {
-                    const summary = perfReport.agentMetrics.get(name);
-                    if (summary) {
-                        console.log(`   - ${name}: ${(summary.averageDuration / 1000).toFixed(2)}s (média)`);
-                    }
-                });
-            }
-
-            if (perfReport.recommendations.length > 0) {
-                console.log(`\n💡 Recomendações:`);
-                perfReport.recommendations.forEach(rec => console.log(`   ${rec}`));
-            }
-
-            // 5. Decisão final
-            const status = success ? 'GO' : 'NO-GO';
-
-            // 🆕 APRENDIZADO AUTOMÁTICO: Atualizar memória dos agentes baseados no resultado FINAL (Build/Audit)
-            console.log('\n🧠 Fase Final: Sincronizando Memória e Aprendizado...');
-            for (const report of reports) {
-                const agent = this.getAgentByName(report.agentName);
-                if (agent && agent instanceof BaseAgent) {
-                    const finalSuccess = success && report.status === 'success';
-                    const context: TaskContext = {
-                        files: implementationPlan?.files.create.map(f => f.path) || [],
-                        areas: analysis.detectedAreas,
-                        complexity: analysis.complexity,
-                    };
-
-                    // Se o projeto falhou no build/audit, o agente "falhou" em garantir a integridade global
-                    await agent.recordOutcome(
-                        report.summary,
-                        context,
-                        { success: finalSuccess, details: report.details },
-                        {
-                            satisfied: finalSuccess,
-                            likes: finalSuccess ? ['Passou na validação final'] : [],
-                            dislikes: !finalSuccess ? ['Falhou na validação global ou audit'] : [],
-                            suggestions: !finalSuccess ? ['Revisar integração com o sistema de build'] : []
-                        }
-                    );
-
-                    if (finalSuccess) {
-                        // Promover a aprendizado automático se teve sucesso
-                        await agent.learn(
-                            taskDescription,
-                            `Implementação bem-sucedida de: ${taskDescription}`,
-                            `Repetir padrões usados em: ${implementationPlan?.title}`,
-                            [this.generateTaskId()]
-                        );
-                    }
-                }
-            }
-
-            console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-            console.log(`${success ? '✅ GO' : '❌ NO-GO'} - Execução ${success ? 'concluída' : 'bloqueada'}`);
-            console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-
-            console.log('Tem algo a modificar a mais ou posso mandar para o github?');
-            console.log('Por favor, faça um resumo do que foi feito para não perder a memória.');
-
-            // 6. Coletar feedback (se habilitado)
-            if (this.config.feedbackEnabled) {
-                await this.collectFeedbackForTask(taskId, selectedAgents, taskDescription);
-            }
-
-            return {
-                success,
-                status,
-                reports,
-                blockers,
-                taskId,
-            };
-
-        } catch (error) {
-            console.error('\n❌ Erro durante execução:', (error as Error).message);
-
-            // NOVO: Rollback em caso de erro
-            if (checkpointId) {
-                console.log('\n🔄 Fazendo rollback...');
-                try {
-                    await this.checkpointManager.rollback(checkpointId);
-                    console.log('✅ Rollback concluído com sucesso');
-                } catch (rollbackError) {
-                    console.error('❌ Erro no rollback:', (rollbackError as Error).message);
-                }
-            }
-
-            return {
-                success: false,
-                status: 'NO-GO',
-                reports: [],
-                blockers: [(error as Error).message],
-                taskId,
-            };
-        }
-    }
-
-    /**
-     * Seleciona melhores agentes baseado em histórico
-     */
-    private async selectBestAgents(analysis: TaskAnalysis): Promise<AgentAssignment[]> {
-        const selectedAgents: AgentAssignment[] = [];
-
-        console.log('🔍 Analisando histórico de performance dos agentes...\n');
-
-        for (const assignment of analysis.agentAssignments) {
-            const stats = this.memory.getStats(assignment.agentName);
-
-            console.log(`📊 ${assignment.agentName}:`);
-            console.log(`   Taxa de sucesso: ${(stats.successRate * 100).toFixed(1)}%`);
-            console.log(`   Total de tarefas: ${stats.totalTasks}`);
-
-            // Sempre incluir, mas mostrar confiança
-            if (stats.successRate >= 0.7 || stats.totalTasks === 0) {
-                console.log(`   ✅ Selecionado (alta confiança)\n`);
-                selectedAgents.push(assignment);
-            } else if (stats.successRate >= 0.5) {
-                console.log(`   ⚠️  Selecionado (confiança média)\n`);
-                selectedAgents.push(assignment);
-            } else {
-                console.log(`   ⚠️  Selecionado (baixa confiança - monitorar)\n`);
-                selectedAgents.push(assignment);
-            }
-        }
-
-        return selectedAgents;
-    }
-
-    /**
-     * Executa tarefa com um agente específico
-     */
-    private async executeWithAgent(
-        assignment: AgentAssignment,
-        analysis: TaskAnalysis
-    ): Promise<AgentReport> {
-        console.log(`━━━ ${assignment.agentName} ━━━`);
-        console.log(`Subtarefa: ${assignment.subtask}\n`);
-        console.log(`🧮 Tokens estimados (subtarefa): ${this.estimateTokens(assignment.subtask)}\n`);
-
+
+    constructor(context: ProjectContext, config: AgentConfig = DEFAULT_CONFIG) {
+        this.context = context;
+        this.config = config;
+        this.taskAnalyzer = new TaskAnalyzerAgent();
+        this.performanceTracker = new PerformanceTracker();
+        this.frontendAgent = new FrontEndAgent();
+        this.securityAgent = new SecurityAgent();
+        this.architectureAgent = new ArchitectureAgent();
+        this.qualityAgent = new QualityAgent();
+        this.documentationAgent = new DocumentationAgent();
+        this.cmsAgent = new CMSAgent();
+        this.seoAgent = new SEOAgent();
+        this.productionControlAgent = new ProductionControlAgent();
+        this.routeAgent = new RouteAgent();
+        const projectRoot = process.cwd();
+        this.planningAgent = new PlanningAgent(undefined, projectRoot);
+        this.checkpointManager = new CheckpointManager(projectRoot);
+        this.fileGenerator = new FileGenerator(projectRoot);
+        this.reportGenerator = new ReportGenerator();
+        this.nextjsAgent = new NextJSAgent();
+        this.uiuxAgent = new UIUXAgent();
+        this.backendAgent = new BackendAgent();
+        this.databaseAgent = new DatabaseAgent();
+        this.aiAgentsAgent = new AIAgentsAgent();
+        this.ragAgent = new RAGAgent();
+        this.pentestAgent = new PentestAgent();
+        this.devopsAgent = new DevOpsAgent();
+        this.cloudAgent = new CloudAgent();
+        this.testingAgent = new TestingAgent();
+        this.croAgent = new CROAgent();
+        this.automationAgent = new AutomationAgent();
+        this.uiDataMapAgent = new UIDataMapAgent();
+        this.stackBoundaryAgent = new StackBoundaryAgent();
+        this.buildManager = new BuildManager(projectRoot);
+    }
+
+    async orchestrateTask(taskDescription: string): Promise<ExecutionResult> {
+        const taskId = this.generateTaskId();
+        const blockers: string[] = [];
+
         try {
-            const context: TaskContext = {
-                files: this.extractFilesForAgent(assignment.agentName, analysis),
-                areas: analysis.detectedAreas,
-                complexity: analysis.complexity,
+            const analysis = await this.taskAnalyzer.analyzeTask(taskDescription, this.config);
+            const implementationPlan = await this.planningAgent.createImplementationPlan(taskDescription);
+            const checkpointId = await this.checkpointManager.createCheckpoint(
+                `pre-implementation-${taskId}`,
+                implementationPlan.files.create.map((file) => file.path)
+            );
+
+            await this.implementPlan(implementationPlan);
+
+            const validationResult = await this.runValidation();
+            if (!validationResult.passed) {
+                blockers.push(...validationResult.errors);
+            }
+
+            const selectedAgents = await this.selectBestAgents(analysis);
+            const reports = await this.runAgentGroups(selectedAgents, analysis);
+            const success = reports.every((report) => report.status !== 'error') && blockers.length === 0;
+
+            if (!success) {
+                try {
+                    await this.checkpointManager.rollback(checkpointId);
+                } catch {
+                    blockers.push('Falha ao restaurar checkpoint');
+                }
+            } else {
+                const changedFiles = [
+                    ...implementationPlan.files.create.map((file) => file.path),
+                    ...implementationPlan.files.modify.map((file) => file.path),
+                ];
+
+                if (changedFiles.length > 0) {
+                    await this.buildManager.createBuild(changedFiles, 'orchestrator', true, taskDescription);
+                }
+            }
+
+            return {
+                success,
+                status: success ? 'GO' : 'NO-GO',
+                reports,
+                blockers,
+                taskId,
             };
+        } catch (error) {
+            return {
+                success: false,
+                status: 'NO-GO',
+                reports: [],
+                blockers: [(error as Error).message],
+                taskId,
+            };
+        }
+    }
+
+    private async selectBestAgents(analysis: TaskAnalysis): Promise<AgentAssignment[]> {
+        return analysis.agentAssignments;
+    }
+
+    private async runAgentGroups(selectedAgents: AgentAssignment[], analysis: TaskAnalysis): Promise<AgentReport[]> {
+        const agentGroups = AgentParallelizer.groupAgents(selectedAgents);
+        const reports: AgentReport[] = [];
+
+        for (const group of agentGroups) {
+            const groupReports = await Promise.all(group.map((assignment) => this.executeWithAgent(assignment, analysis)));
+            reports.push(...groupReports);
+            if (groupReports.some((report) => report.status === 'error')) {
+                break;
+            }
+        }
 
-            const agentInstance = this.getAgentByName(assignment.agentName);
-            let result: TaskResult;
-
-            // Iniciar tracking de performance
-            const taskId = this.generateTaskId();
-            const trackingId = this.performanceTracker.startTracking(
-                assignment.agentName,
-                taskId,
-                'full-execution'
-            );
-
-            // Executar com timeout e retry
-            result = await RetryUtility.executeWithTimeoutAndRetry(
-                async () => {
-                    // Executar com o agente apropriado
-                    switch (assignment.agentName) {
-                        case 'frontend-agent':
-                            return await this.frontendAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'security-agent':
-                            return await this.securityAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'architecture-agent':
-                            return await this.architectureAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'quality-agent':
-                            return await this.qualityAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'documentation-agent':
-                            return await this.documentationAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'inventory-agent':
-                            return await this.inventoryAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'cms-agent':
-                            return await this.cmsAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'seo-agent':
-                            return await this.seoAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'production-control-agent':
-                            return await this.productionControlAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'route-agent':
-                            return await this.routeAgent.executeWithMemory(assignment.subtask, context);
-
-                        // NEW: 12 Specialized Agents (with Memory System)
-                        case 'nextjs-agent':
-                            return await this.nextjsAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'uiux-agent':
-                            return await this.uiuxAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'backend-agent':
-                            return await this.backendAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'database-agent':
-                            return await this.databaseAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'ai-agents-agent':
-                            return await this.aiAgentsAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'rag-agent':
-                            return await this.ragAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'pentest-agent':
-                            return await this.pentestAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'devops-agent':
-                            return await this.devopsAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'cloud-agent':
-                            return await this.cloudAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'testing-agent':
-                            return await this.testingAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'cro-agent':
-                            return await this.croAgent.executeWithMemory(assignment.subtask, context);
-
-                        case 'automation-agent':
-                            return await this.automationAgent.executeWithMemory(assignment.subtask, context);
-                        case 'ui-data-map-agent':
-                            return await this.uiDataMapAgent.executeWithMemory(assignment.subtask, context);
-                        case 'stack-boundary-agent':
-                            return await this.stackBoundaryAgent.executeWithMemory(assignment.subtask, context);
-
-                        default:
-                            // Agente não implementado ainda
-                            return {
-                                success: true,
-                                details: `Agente ${assignment.agentName} ainda não implementado`,
-                                warnings: ['Agente em desenvolvimento'],
-                            };
-                    }
-                },
-                30000, // 30 segundos de timeout
-                {
-                    maxRetries: 2,
-                    initialDelay: 2000,
-                    backoffMultiplier: 2
-                },
-                assignment.agentName
+        return reports;
+    }
+
+    private async executeWithAgent(assignment: AgentAssignment, analysis: TaskAnalysis): Promise<AgentReport> {
+        const context: TaskContext = {
+            files: [],
+            areas: analysis.detectedAreas,
+            complexity: analysis.complexity,
+        };
+
+        const agentInstance = this.getAgentByName(assignment.agentName);
+        const trackingId = this.performanceTracker.startTracking(
+            assignment.agentName,
+            this.generateTaskId(),
+            'full-execution'
+        );
+
+        try {
+            const result = await RetryUtility.executeWithTimeoutAndRetry(
+                async () => this.executeAgentByName(assignment.agentName, assignment.subtask, context),
+                30000,
+                { maxRetries: 2, initialDelay: 2000, backoffMultiplier: 2 },
+                assignment.agentName
             );
 
             let status: AgentReport['status'] = result.success ? 'success' : 'error';
-            const blockers: string[] = [...(result.issues || [])];
+            const blockers = [...(result.issues || [])];
 
-            if (agentInstance && agentInstance instanceof BaseAgent) {
+            if (agentInstance instanceof BaseAgent) {
                 const validator = new WorkflowValidator();
                 const validation = validator.validateAgentExecution(
                     assignment.agentName,
                     agentInstance.getWorkflowSteps()
                 );
-                const report = validator.generateValidationReport(assignment.agentName, validation);
-                console.log(report);
 
                 if (!validation.compliant) {
                     status = 'error';
-                    blockers.push(
-                        `Workflow NON-COMPLIANT: passos faltantes - ${validation.missingSteps.join(', ')}`
-                    );
+                    blockers.push(`Workflow NON-COMPLIANT: ${validation.missingSteps.join(', ')}`);
                 }
             }
 
-            // Finalizar tracking de performance
             this.performanceTracker.endTracking(trackingId, result.success);
-
-            console.log(`${result.success ? '✅' : '❌'} ${assignment.agentName} concluído\n`);
-
+
             return {
                 agentName: assignment.agentName,
                 stepNumber: assignment.priority,
                 status,
-                summary: result.success ? 'Tarefa concluída com sucesso' : 'Tarefa falhou',
+                summary: result.success ? 'Tarefa concluída com sucesso' : 'Tarefa falhou',
                 details: result.details,
                 blockers: blockers.length > 0 ? blockers : undefined,
             };
-
-        } catch (error) {
-            console.error(`❌ Erro ao executar ${assignment.agentName}:`, error);
-
-            // Finalizar tracking de performance com erro
-            // Note: trackingId pode não existir se erro ocorreu antes do tracking iniciar
-            try {
-                const taskId = this.generateTaskId();
-                const trackingId = this.performanceTracker.startTracking(
-                    assignment.agentName,
-                    taskId,
-                    'full-execution'
-                );
-                this.performanceTracker.endTracking(
-                    trackingId,
-                    false,
-                    error instanceof Error ? error.message : 'Erro desconhecido'
-                );
-            } catch (trackingError) {
-                // Ignorar erros de tracking
-            }
-
-            return {
-                agentName: assignment.agentName,
-                stepNumber: assignment.priority,
-                status: 'error',
-                summary: 'Erro na execução',
-                details: error instanceof Error ? error.message : 'Erro desconhecido',
-                blockers: ['Erro crítico na execução'],
-            };
-        }
-    }
-
-    /**
-     * Verifica duplicação de recursos antes da execução
-     */
-    private async checkDuplicationBeforeExecution(taskDescription: string): Promise<void> {
-        console.log('🛡️  Consulando Almoxarifado (Inventory Agent) para evitar duplicações...');
-
-        // Simular contexto para o Inventory Agent
-        const context: TaskContext = {
-            files: [],
-            areas: ['inventory'],
-            complexity: 'low'
-        };
-
-        const result = await this.inventoryAgent.executeWithMemory(`check duplication for "${taskDescription}"`, context);
-
-        if (result.warnings && result.warnings.length > 0) {
-            console.log('\n⚠️  ALERTA DE DUPLICAÇÃO DETECTADO:');
-            result.warnings.forEach(w => console.log(`   - ${w}`));
-            if (result.recommendations) {
-                console.log('\n💡 Sugestões do Almoxarifado:');
-                result.recommendations.forEach(r => console.log(`   - ${r}`));
-            }
-            console.log('\n');
-        } else {
-            console.log('✅ Nenhuma duplicação óbvia detectada. Prosseguindo...\n');
-        }
-    }
-
-    /**
-     * Extrai arquivos relevantes para um agente
-     */
-    private extractFilesForAgent(agentName: string, analysis: TaskAnalysis): string[] {
-        // Implementação simplificada - em produção seria mais sofisticado
-        // Por enquanto, retorna lista vazia (agentes usarão arquivos do contexto geral)
-        return [];
-    }
-
-    /**
-     * Coleta feedback para a tarefa
-     */
-    private async collectFeedbackForTask(
-        taskId: string,
-        agents: AgentAssignment[],
-        taskDescription: string
-    ): Promise<void> {
-        console.log('\n📝 Feedback habilitado - aguardando feedback do usuário');
-        console.log('   Use feedbackCollector.provideFeedback() para fornecer feedback\n');
-
-        // Em produção, isso seria um prompt interativo
-        // Por enquanto, apenas informamos que o feedback está disponível
-        for (const agent of agents) {
-            await this.feedbackCollector.collectFeedback(
-                taskId,
-                agent.agentName,
-                taskDescription
-            );
-        }
-    }
-
-    /**
-     * Fornece feedback manualmente
-     */
-    async provideFeedback(taskId: string, agentName: string, feedback: Omit<UserFeedback, 'taskId' | 'agentName' | 'timestamp'>): Promise<void> {
-        const fullFeedback: UserFeedback = {
-            taskId,
-            agentName,
-            ...feedback,
-            timestamp: new Date(),
-        };
-
-        await this.feedbackCollector.provideFeedback(fullFeedback);
-    }
-
-    /**
-     * Gera relatório de feedback de um agente
-     */
-    getFeedbackReport(agentName: string): string {
-        return this.feedbackCollector.generateFeedbackReport(agentName);
-    }
-
-    /**
-     * NOVO: Implementa o plano criado pelo planning agent
-     */
-    private async implementPlan(plan: ImplementationPlan): Promise<void> {
-        console.log(`📝 Implementando ${plan.files.create.length} arquivo(s)...\\n`);
-
-        // Criar arquivos
-        for (const file of plan.files.create) {
-            await this.fileGenerator.createFile(file.path, file.type, file.purpose, plan);
-        }
-
-        // Modificar arquivos existentes
-        for (const file of plan.files.modify) {
-            await this.fileGenerator.modifyFile(file.path, file.changes);
-        }
-
-        // Deletar arquivos
-        for (const file of plan.files.delete) {
-            await this.fileGenerator.deleteFile(file);
-        }
-
-        console.log(`\\n✅ Implementação concluída!`);
-    }
-
-    /**
-     * NOVO: Executa validação automática
-     */
-    private async runValidation(): Promise<{ passed: boolean; errors: string[] }> {
-        const errors: string[] = [];
-
-        try {
-            // Executar validate
-            console.log('   Executando npm run validate...');
-            const { execSync } = await import('child_process');
-            execSync('npm run validate', { stdio: 'pipe' });
-            console.log('   ✅ Validate passou');
-        } catch (error) {
-            errors.push('Validate falhou');
-            console.log('   ❌ Validate falhou');
-        }
-
-        return {
-            passed: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Gera ID único para tarefa
-     */
+        } catch (error) {
+            this.performanceTracker.endTracking(
+                trackingId,
+                false,
+                error instanceof Error ? error.message : 'Erro desconhecido'
+            );
+
+            return {
+                agentName: assignment.agentName,
+                stepNumber: assignment.priority,
+                status: 'error',
+                summary: 'Erro na execução',
+                details: error instanceof Error ? error.message : 'Erro desconhecido',
+                blockers: ['Erro crítico na execução'],
+            };
+        }
+    }
+
+    private async executeAgentByName(agentName: string, subtask: string, context: TaskContext): Promise<TaskResult> {
+        switch (agentName) {
+            case 'frontend-agent': return this.frontendAgent.executeWithMemory(subtask, context);
+            case 'security-agent': return this.securityAgent.executeWithMemory(subtask, context);
+            case 'architecture-agent': return this.architectureAgent.executeWithMemory(subtask, context);
+            case 'quality-agent': return this.qualityAgent.executeWithMemory(subtask, context);
+            case 'documentation-agent': return this.documentationAgent.executeWithMemory(subtask, context);
+            case 'cms-agent': return this.cmsAgent.executeWithMemory(subtask, context);
+            case 'seo-agent': return this.seoAgent.executeWithMemory(subtask, context);
+            case 'production-control-agent': return this.productionControlAgent.executeWithMemory(subtask, context);
+            case 'route-agent': return this.routeAgent.executeWithMemory(subtask, context);
+            case 'nextjs-agent': return this.nextjsAgent.executeWithMemory(subtask, context);
+            case 'uiux-agent': return this.uiuxAgent.executeWithMemory(subtask, context);
+            case 'backend-agent': return this.backendAgent.executeWithMemory(subtask, context);
+            case 'database-agent': return this.databaseAgent.executeWithMemory(subtask, context);
+            case 'ai-agents-agent': return this.aiAgentsAgent.executeWithMemory(subtask, context);
+            case 'rag-agent': return this.ragAgent.executeWithMemory(subtask, context);
+            case 'pentest-agent': return this.pentestAgent.executeWithMemory(subtask, context);
+            case 'devops-agent': return this.devopsAgent.executeWithMemory(subtask, context);
+            case 'cloud-agent': return this.cloudAgent.executeWithMemory(subtask, context);
+            case 'testing-agent': return this.testingAgent.executeWithMemory(subtask, context);
+            case 'cro-agent': return this.croAgent.executeWithMemory(subtask, context);
+            case 'automation-agent': return this.automationAgent.executeWithMemory(subtask, context);
+            case 'ui-data-map-agent': return this.uiDataMapAgent.executeWithMemory(subtask, context);
+            case 'stack-boundary-agent': return this.stackBoundaryAgent.executeWithMemory(subtask, context);
+            default:
+                return {
+                    success: true,
+                    details: `Agente ${agentName} ainda não implementado`,
+                    warnings: ['Agente em desenvolvimento'],
+                };
+        }
+    }
+
+    async provideFeedback(): Promise<void> {
+        return;
+    }
+
+    getFeedbackReport(): string {
+        return 'Sistema de feedback removido.';
+    }
+
+    private async implementPlan(plan: ImplementationPlan): Promise<void> {
+        for (const file of plan.files.create) {
+            await this.fileGenerator.createFile(file.path, file.type, file.purpose, plan);
+        }
+        for (const file of plan.files.modify) {
+            await this.fileGenerator.modifyFile(file.path, file.changes);
+        }
+        for (const file of plan.files.delete) {
+            await this.fileGenerator.deleteFile(file);
+        }
+    }
+
+    private async runValidation(): Promise<{ passed: boolean; errors: string[] }> {
+        const errors: string[] = [];
+        try {
+            const { execSync } = await import('child_process');
+            execSync('npm run validate', { stdio: 'pipe' });
+        } catch {
+            errors.push('Validate falhou');
+        }
+        return { passed: errors.length === 0, errors };
+    }
+
     private generateTaskId(): string {
-        return `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        return `task-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
     }
 
-    private estimateTokens(text: string): number {
-        const normalized = text.trim();
-        if (!normalized) return 0;
-        return Math.ceil(normalized.length / 4);
+    async analyzeBeforeExecution(taskDescription: string): Promise<TaskAnalysis> {
+        return this.taskAnalyzer.analyzeTask(taskDescription, this.config);
     }
-
-    /**
-     * Método legado para compatibilidade
-     */
-    async analyzeBeforeExecution(taskDescription: string): Promise<TaskAnalysis> {
-        return await this.taskAnalyzer.analyzeTask(taskDescription, this.config);
-    }
-
-    /**
-     * Método legado para compatibilidade
-     */
-    async executePlan(plan: ImplementationPlan): Promise<ExecutionResult> {
-        // Converter plano para descrição de tarefa
-        const taskDescription = `${plan.title}: ${plan.description}`;
-        return await this.orchestrateTask(taskDescription);
-    }
-
-    /**
-     * Retorna a instância de um agente pelo nome
-     */
-    private getAgentByName(name: string): any {
-        const agentsMap: Record<string, any> = {
-            'frontend-agent': this.frontendAgent,
-            'security-agent': this.securityAgent,
-            'architecture-agent': this.architectureAgent,
-            'quality-agent': this.qualityAgent,
-            'documentation-agent': this.documentationAgent,
-            'inventory-agent': this.inventoryAgent,
-            'cms-agent': this.cmsAgent,
-            'seo-agent': this.seoAgent,
-            'production-control-agent': this.productionControlAgent,
-            'route-agent': this.routeAgent,
-            'nextjs-agent': this.nextjsAgent,
-            'uiux-agent': this.uiuxAgent,
-            'backend-agent': this.backendAgent,
-            'database-agent': this.databaseAgent,
-            'ai-agents-agent': this.aiAgentsAgent,
-            'rag-agent': this.ragAgent,
-            'pentest-agent': this.pentestAgent,
-            'devops-agent': this.devopsAgent,
-            'cloud-agent': this.cloudAgent,
+
+    async executePlan(plan: ImplementationPlan): Promise<ExecutionResult> {
+        return this.orchestrateTask(`${plan.title}: ${plan.description}`);
+    }
+
+    private getAgentByName(name: string): any {
+        const agentsMap: Record<string, any> = {
+            'frontend-agent': this.frontendAgent,
+            'security-agent': this.securityAgent,
+            'architecture-agent': this.architectureAgent,
+            'quality-agent': this.qualityAgent,
+            'documentation-agent': this.documentationAgent,
+            'cms-agent': this.cmsAgent,
+            'seo-agent': this.seoAgent,
+            'production-control-agent': this.productionControlAgent,
+            'route-agent': this.routeAgent,
+            'nextjs-agent': this.nextjsAgent,
+            'uiux-agent': this.uiuxAgent,
+            'backend-agent': this.backendAgent,
+            'database-agent': this.databaseAgent,
+            'ai-agents-agent': this.aiAgentsAgent,
+            'rag-agent': this.ragAgent,
+            'pentest-agent': this.pentestAgent,
+            'devops-agent': this.devopsAgent,
+            'cloud-agent': this.cloudAgent,
             'testing-agent': this.testingAgent,
             'cro-agent': this.croAgent,
             'automation-agent': this.automationAgent,
             'ui-data-map-agent': this.uiDataMapAgent,
-            'stack-boundary-agent': this.stackBoundaryAgent
+            'stack-boundary-agent': this.stackBoundaryAgent,
         };
         return agentsMap[name];
     }
 }
-
-// Manter compatibilidade com código existente
-export { IntelligentOrchestrator as AgentsOrchestrator };
-
+
+export { IntelligentOrchestrator as AgentsOrchestrator };