claude-flow 2.7.0-alpha.9 → 2.7.0

package/dist/cli/simple-commands/automation-executor.js

@@ -0,0 +1,1383 @@
+/**
+ * Modular Automation Executor for Claude Flow
+ *
+ * This module provides the core infrastructure for executing automation
+ * workflows with Claude CLI integration, while preserving existing
+ * swarm and hive-mind functionality.
+ */
+import { promises as fs } from 'fs';
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { printSuccess, printError, printWarning } from '../utils.js';
+// Simple ID generator
+function generateId(prefix = 'id') {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * WorkflowExecutor - Core class for executing automation workflows
+ */
+export class WorkflowExecutor {
+    constructor(options = {}) {
+        this.options = {
+            enableClaude: false,
+            nonInteractive: false,
+            outputFormat: 'text',
+            maxConcurrency: 3,
+            timeout: 3600000, // 1 hour default
+            logLevel: 'info',
+            ...options
+        };
+        // Increase timeout for ML workflows
+        if (options.workflowType === 'ml' || options.workflowName?.toLowerCase().includes('mle')) {
+            this.options.timeout = 7200000; // 2 hours for ML workflows
+        }
+        // Execution state
+        this.executionId = generateId('workflow-exec');
+        this.startTime = Date.now();
+        this.activeTasks = new Map();
+        this.claudeInstances = new Map();
+        this.results = new Map();
+        this.errors = [];
+        this.currentWorkflow = null;
+        // Stream chaining support
+        this.taskOutputStreams = new Map(); // Store output streams for chaining
+        this.enableChaining = options.enableChaining !== false; // Default to true
+        // Hooks integration
+        this.hooksEnabled = true;
+        this.sessionId = generateId('automation-session');
+    }
+    /**
+     * Execute a workflow from JSON definition
+     */
+    async executeWorkflow(workflowData, variables = {}) {
+        try {
+            // Store workflow for reference
+            this.currentWorkflow = workflowData;
+            if (this.options.logLevel === 'quiet') {
+                console.log(`🚀 Executing workflow: ${this.executionId}`);
+            }
+            else {
+                console.log(`🚀 Starting workflow execution: ${this.executionId}`);
+                console.log(`📋 Workflow: ${workflowData.name}`);
+                console.log(`🎯 Strategy: MLE-STAR Machine Learning Engineering`);
+                if (this.options.enableClaude) {
+                    console.log(`🤖 Claude CLI Integration: Enabled`);
+                }
+                if (this.options.nonInteractive) {
+                    console.log(`🖥️  Non-Interactive Mode: Enabled`);
+                    if (this.options.outputFormat === 'stream-json') {
+                        console.log();
+                        console.log('● Running MLE-STAR workflow with Claude CLI integration');
+                        console.log('  ⎿  Command format: claude --print --output-format stream-json --verbose --dangerously-skip-permissions');
+                        console.log('  ⎿  Each agent will show real-time stream output below');
+                        console.log('  ⎿  Interactive-style formatting enabled');
+                    }
+                }
+            }
+            console.log();
+            // Pre-execution hooks
+            if (this.hooksEnabled) {
+                await this.executeHook('pre-task', {
+                    description: `Execute workflow: ${workflowData.name}`,
+                    sessionId: this.sessionId
+                });
+            }
+            // Validate workflow
+            this.validateWorkflow(workflowData);
+            // Apply variable substitutions
+            const processedWorkflow = this.applyVariables(workflowData, variables);
+            // Initialize agents if Claude integration is enabled
+            if (this.options.enableClaude) {
+                await this.initializeClaudeAgents(processedWorkflow.agents);
+            }
+            // Execute workflow phases
+            const result = await this.executeWorkflowTasks(processedWorkflow);
+            // Post-execution hooks
+            if (this.hooksEnabled) {
+                await this.executeHook('post-task', {
+                    taskId: this.executionId,
+                    sessionId: this.sessionId,
+                    result: result.success ? 'success' : 'failure'
+                });
+            }
+            const duration = Date.now() - this.startTime;
+            if (result.success) {
+                printSuccess(`✅ Workflow completed successfully in ${this.formatDuration(duration)}`);
+                console.log(`📊 Tasks: ${result.completedTasks}/${result.totalTasks} completed`);
+                console.log(`🆔 Execution ID: ${this.executionId}`);
+            }
+            else {
+                printError(`❌ Workflow failed after ${this.formatDuration(duration)}`);
+                console.log(`📊 Tasks: ${result.completedTasks}/${result.totalTasks} completed`);
+                console.log(`❌ Errors: ${this.errors.length}`);
+            }
+            // Cleanup Claude instances
+            if (this.options.enableClaude) {
+                await this.cleanupClaudeInstances();
+            }
+            return result;
+        }
+        catch (error) {
+            printError(`Workflow execution failed: ${error.message}`);
+            await this.cleanupClaudeInstances();
+            throw error;
+        }
+    }
+    /**
+     * Initialize Claude CLI instances for agents
+     */
+    async initializeClaudeAgents(agents) {
+        if (!agents || agents.length === 0) {
+            return;
+        }
+        // Check if Claude CLI is available
+        if (!await this.isClaudeAvailable()) {
+            throw new Error('Claude CLI not found. Please install Claude Code: https://claude.ai/code');
+        }
+        if (this.options.nonInteractive) {
+            // Non-interactive mode: agents are spawned per task instead
+            if (this.options.logLevel !== 'quiet') {
+                console.log(`🤖 Non-interactive mode: Claude instances will be spawned per task`);
+                console.log(`📋 Each task will launch its own Claude process with specific prompts`);
+            }
+            return;
+        }
+        else {
+            // Interactive mode: spawn single Claude instance with master coordination prompt
+            console.log(`🤖 Interactive mode: Initializing single Claude instance for workflow coordination...`);
+            try {
+                // Create master coordination prompt for all agents and workflow
+                const masterPrompt = this.createMasterCoordinationPrompt(agents);
+                // Spawn single Claude instance for workflow coordination
+                const claudeProcess = await this.spawnClaudeInstance({
+                    id: 'master-coordinator',
+                    name: 'Workflow Coordinator',
+                    type: 'coordinator'
+                }, masterPrompt);
+                // Store as master coordinator
+                this.claudeInstances.set('master-coordinator', {
+                    process: claudeProcess,
+                    agent: { id: 'master-coordinator', name: 'Workflow Coordinator', type: 'coordinator' },
+                    status: 'active',
+                    startTime: Date.now(),
+                    agents: agents // Store agent definitions for reference
+                });
+                console.log(`  ✅ Master Workflow Coordinator (PID: ${claudeProcess.pid})`);
+                console.log(`  🎯 Coordinating ${agents.length} sub-agents via concurrent streams`);
+                console.log(`  📋 Agents: ${agents.map(a => a.name).join(', ')}`);
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to initialize master coordinator: ${error.message}`);
+                this.errors.push({
+                    type: 'master_coordinator_initialization',
+                    error: error.message,
+                    timestamp: new Date()
+                });
+            }
+            console.log();
+        }
+    }
+    /**
+     * Check if Claude CLI is available
+     */
+    async isClaudeAvailable() {
+        try {
+            const { execSync } = await import('child_process');
+            execSync('which claude', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Spawn a Claude CLI instance for an agent
+     * @param {Object} agent - The agent configuration
+     * @param {string} prompt - The prompt for the agent
+     * @param {Object} options - Additional options
+     * @param {Stream} options.inputStream - Optional input stream from previous agent
+     * @param {boolean} options.enableChaining - Whether to enable stream-json chaining
+     */
+    async spawnClaudeInstance(agent, prompt, options = {}) {
+        const claudeArgs = [];
+        // Add flags based on mode
+        if (this.options.nonInteractive) {
+            // Non-interactive mode: use --print with stream-json output
+            claudeArgs.push('--print');
+            if (this.options.outputFormat === 'stream-json') {
+                claudeArgs.push('--output-format', 'stream-json');
+                claudeArgs.push('--verbose'); // Required for stream-json
+                // Add input format if we're chaining from a previous agent
+                if (options.inputStream) {
+                    claudeArgs.push('--input-format', 'stream-json');
+                }
+            }
+        }
+        // Always skip permissions for automated workflows (both interactive and non-interactive)
+        claudeArgs.push('--dangerously-skip-permissions');
+        // Always add the prompt as the final argument
+        claudeArgs.push(prompt);
+        // Only show command details in verbose mode
+        if (this.options.logLevel === 'debug') {
+            const displayPrompt = prompt.length > 100 ? prompt.substring(0, 100) + '...' : prompt;
+            const flagsDisplay = this.options.nonInteractive ?
+                (this.options.outputFormat === 'stream-json' ?
+                    (options.inputStream ? '--print --input-format stream-json --output-format stream-json --verbose --dangerously-skip-permissions' : '--print --output-format stream-json --verbose --dangerously-skip-permissions') :
+                    '--print --dangerously-skip-permissions') :
+                '--dangerously-skip-permissions';
+            console.log(`    🤖 Spawning Claude for ${agent.name}: claude ${flagsDisplay} "${displayPrompt}"`);
+        }
+        else if (this.options.logLevel !== 'quiet') {
+            console.log(`    🚀 Starting ${agent.name}`);
+        }
+        // Determine stdio configuration based on mode and chaining
+        const stdioConfig = this.options.nonInteractive ?
+            [options.inputStream ? 'pipe' : 'inherit', 'pipe', 'pipe'] : // Non-interactive: pipe for chaining
+            ['inherit', 'inherit', 'inherit']; // Interactive: inherit all for normal Claude interaction
+        // Spawn Claude process
+        const claudeProcess = spawn('claude', claudeArgs, {
+            stdio: stdioConfig,
+            shell: false,
+        });
+        // If we have an input stream, pipe it to Claude's stdin
+        if (options.inputStream && claudeProcess.stdin) {
+            console.log(`    🔗 Chaining: Piping output from previous agent to ${agent.name}`);
+            options.inputStream.pipe(claudeProcess.stdin);
+        }
+        // Handle stdout with stream processor for better formatting (only in non-interactive mode)
+        if (this.options.nonInteractive && this.options.outputFormat === 'stream-json' && claudeProcess.stdout) {
+            // Import and use stream processor
+            const { createStreamProcessor } = await import('./stream-processor.js');
+            const streamProcessor = createStreamProcessor(agent.name, this.getAgentIcon(agent.id), {
+                verbose: this.options.logLevel === 'debug',
+                logLevel: this.options.logLevel,
+                taskId: agent.taskId,
+                agentId: agent.id,
+                display: null // Interactive-style formatting instead of concurrent display
+            });
+            // Pipe stdout through processor
+            claudeProcess.stdout.pipe(streamProcessor);
+            // Handle stderr for non-interactive mode
+            claudeProcess.stderr.on('data', (data) => {
+                const message = data.toString().trim();
+                if (message) {
+                    console.error(`    ❌ [${agent.name}] Error: ${message}`);
+                }
+            });
+        }
+        else if (this.options.nonInteractive && this.options.outputFormat !== 'stream-json') {
+            // For non-interactive non-stream-json output, show stdout directly
+            claudeProcess.stdout.on('data', (data) => {
+                console.log(data.toString().trimEnd());
+            });
+            claudeProcess.stderr.on('data', (data) => {
+                console.error(data.toString().trimEnd());
+            });
+        }
+        // Note: In interactive mode, stdio is inherited so Claude handles its own I/O
+        // Handle process events
+        claudeProcess.on('error', (error) => {
+            console.error(`❌ Claude instance error for ${agent.name}:`, error.message);
+            this.errors.push({
+                type: 'claude_instance_error',
+                agent: agent.id,
+                error: error.message,
+                timestamp: new Date()
+            });
+        });
+        claudeProcess.on('exit', (code) => {
+            const instance = this.claudeInstances.get(agent.id);
+            if (instance) {
+                instance.status = code === 0 ? 'completed' : 'failed';
+                instance.exitCode = code;
+                instance.endTime = Date.now();
+            }
+        });
+        return claudeProcess;
+    }
+    /**
+     * Handle Claude stream events
+     */
+    handleClaudeStreamEvent(agent, event) {
+        if (this.options.outputFormat === 'stream-json') {
+            // Create concise formatted JSON with summary
+            const summary = this.getEventSummary(event);
+            const icon = this.getEventIcon(event.type);
+            // Simplified output for better readability
+            const output = {
+                t: new Date().toISOString().split('T')[1].split('.')[0], // HH:MM:SS
+                agent: `${this.getAgentIcon(agent.id)} ${agent.name}`,
+                phase: this.currentPhase,
+                event: `${icon} ${summary}`
+            };
+            // Add relevant details based on event type
+            if (event.type === 'tool_use' && event.name) {
+                output.tool = event.name;
+            }
+            else if (event.type === 'error' && event.error) {
+                output.error = event.error;
+            }
+            console.log(JSON.stringify(output));
+        }
+        else {
+            // Format output for text mode
+            switch (event.type) {
+                case 'tool_use':
+                    console.log(`    [${agent.name}] 🔧 Using tool: ${event.name}`);
+                    break;
+                case 'message':
+                    console.log(`    [${agent.name}] 💬 ${event.content}`);
+                    break;
+                case 'completion':
+                    console.log(`    [${agent.name}] ✅ Task completed`);
+                    break;
+                case 'error':
+                    console.error(`    [${agent.name}] ❌ Error: ${event.error}`);
+                    break;
+                default:
+                    // Log other events in debug mode
+                    if (this.options.logLevel === 'debug') {
+                        console.log(`    [${agent.name}] ${event.type}: ${JSON.stringify(event)}`);
+                    }
+            }
+        }
+    }
+    /**
+     * Get a brief summary of an event
+     */
+    getEventSummary(event) {
+        switch (event.type) {
+            case 'tool_use':
+                return `Using ${event.name} tool`;
+            case 'message':
+                return event.content?.substring(0, 100) + (event.content?.length > 100 ? '...' : '');
+            case 'completion':
+                return 'Task completed successfully';
+            case 'error':
+                return `Error: ${event.error}`;
+            case 'status':
+                return event.status || 'Status update';
+            default:
+                return event.type;
+        }
+    }
+    /**
+     * Get icon for event type
+     */
+    getEventIcon(eventType) {
+        const icons = {
+            'tool_use': '🔧',
+            'message': '💬',
+            'completion': '✅',
+            'error': '❌',
+            'status': '📊',
+            'init': '🚀',
+            'thinking': '🤔',
+            'result': '📋'
+        };
+        return icons[eventType] || '📌';
+    }
+    /**
+     * Create task-specific Claude prompt with comprehensive MLE-STAR instructions
+     */
+    createTaskPrompt(task, agent, workflow) {
+        // Use the claudePrompt from the task if available
+        if (task.claudePrompt) {
+            // Apply variable substitutions to the prompt
+            let basePrompt = task.claudePrompt;
+            const allVariables = { ...workflow.variables, ...task.input };
+            for (const [key, value] of Object.entries(allVariables)) {
+                const pattern = new RegExp(`\\$\\{${key}\\}`, 'g');
+                basePrompt = basePrompt.replace(pattern, value);
+            }
+            // Create comprehensive task prompt with MLE-STAR methodology
+            return `🎯 MLE-STAR AGENT TASK EXECUTION
+
+You are the **${agent.name}** (${agent.type}) in a coordinated MLE-STAR automation workflow.
+
+📋 IMMEDIATE TASK:
+${basePrompt}
+
+🤖 AGENT ROLE & SPECIALIZATION:
+${this.getAgentRoleDescription(agent.type)}
+
+🎯 AGENT CAPABILITIES:
+${agent.config?.capabilities?.join(', ') || 'general automation'}
+
+🔬 MLE-STAR METHODOLOGY FOCUS:
+${this.getMethodologyGuidance(agent.type)}
+
+🔧 COORDINATION REQUIREMENTS:
+1. **HOOKS INTEGRATION** (CRITICAL):
+   - BEFORE starting: \`npx claude-flow@alpha hooks pre-task --description "${task.description}"\`
+   - AFTER each file operation: \`npx claude-flow@alpha hooks post-edit --file "[filepath]"\`
+   - WHEN complete: \`npx claude-flow@alpha hooks post-task --task-id "${task.id}"\`
+
+2. **MEMORY STORAGE** (CRITICAL):
+   - Store findings: \`npx claude-flow@alpha memory store "agent/${agent.id}/findings" "[your_findings]"\`
+   - Store results: \`npx claude-flow@alpha memory store "agent/${agent.id}/results" "[your_results]"\`
+   - Check other agents: \`npx claude-flow@alpha memory search "agent/*"\`
+
+3. **SESSION COORDINATION**:
+   - Session ID: ${this.sessionId}
+   - Execution ID: ${this.executionId}
+   - Task ID: ${task.id}
+   - Agent ID: ${agent.id}
+
+4. **WORKFLOW PIPELINE AWARENESS**:
+   - Your position: ${this.getAgentPositionInPipeline(agent.type)}
+   - Coordinate with: ${this.getCoordinationPartners(agent.type)}
+   - File naming: Use \`${agent.id}_[component].[ext]\` convention
+
+5. **OUTPUT REQUIREMENTS**:
+   - Use detailed progress reporting
+   - Document methodology decisions
+   - Provide clear deliverables
+   - Follow MLE-STAR best practices for your role
+
+🚀 EXECUTION INSTRUCTIONS:
+1. Start with hooks pre-task command
+2. Execute your specialized MLE-STAR role
+3. Store all findings and results in memory
+4. Coordinate with other agents as needed
+5. Complete with hooks post-task command
+6. Exit when task is fully complete
+
+🎯 SUCCESS CRITERIA:
+- Task objective completed according to MLE-STAR methodology
+- All coordination hooks executed successfully  
+- Results stored in memory for other agents
+- Clear documentation of approach and findings
+- Ready for next pipeline phase
+
+Begin execution now with the hooks pre-task command.`;
+        }
+        else {
+            // Fallback to full agent prompt
+            return this.createAgentPrompt(agent);
+        }
+    }
+    /**
+     * Create agent-specific Claude prompt
+     */
+    createAgentPrompt(agent) {
+        const { config } = agent;
+        const capabilities = config?.capabilities?.join(', ') || 'general automation';
+        return `You are the ${agent.name} in a coordinated MLE-STAR automation workflow.
+
+🎯 AGENT ROLE: ${agent.type.toUpperCase()}
+📋 CAPABILITIES: ${capabilities}
+🆔 AGENT ID: ${agent.id}
+
+CRITICAL COORDINATION REQUIREMENTS:
+1. HOOKS: Use claude-flow hooks for coordination:
+   - Run "npx claude-flow@alpha hooks pre-task --description '[your task]'" before starting
+   - Run "npx claude-flow@alpha hooks post-edit --file '[file]'" after each file operation  
+   - Run "npx claude-flow@alpha hooks post-task --task-id '${agent.id}'" when complete
+
+2. MEMORY: Store all findings and results:
+   - Use "npx claude-flow@alpha memory store 'agent/${agent.id}/[key]' '[value]'" for important data
+   - Check "npx claude-flow@alpha memory search 'agent/*'" for coordination with other agents
+
+3. SESSION: Maintain session coordination:
+   - Session ID: ${this.sessionId}
+   - Execution ID: ${this.executionId}
+
+AGENT-SPECIFIC CONFIGURATION:
+${JSON.stringify(config, null, 2)}
+
+MLE-STAR METHODOLOGY FOCUS:
+${this.getMethodologyGuidance(agent.type)}
+
+WORKFLOW COORDINATION:
+- Work with other agents in the pipeline: Search → Foundation → Refinement → Ensemble → Validation
+- Share findings through memory system
+- Use proper file naming conventions: ${agent.id}_[component].[ext]
+- Follow MLE-STAR best practices for your role
+
+Execute your role in the MLE-STAR workflow with full coordination and hook integration.`;
+    }
+    /**
+     * Create master coordination prompt for interactive mode
+     */
+    createMasterCoordinationPrompt(agents) {
+        const workflowData = this.currentWorkflow || { name: 'MLE-STAR Workflow', description: 'Machine Learning Engineering via Search and Targeted Refinement' };
+        return `🚀 MLE-STAR WORKFLOW COORDINATION MASTER
+
+You are the MASTER COORDINATOR for a comprehensive MLE-STAR (Machine Learning Engineering via Search and Targeted Refinement) workflow. 
+
+📋 WORKFLOW: ${workflowData.name}
+🎯 DESCRIPTION: ${workflowData.description}
+🆔 EXECUTION ID: ${this.executionId}
+🔄 SESSION ID: ${this.sessionId}
+
+🤖 SUB-AGENTS TO COORDINATE (${agents.length} total):
+${agents.map((agent, index) => `
+${index + 1}. ${agent.name} (${agent.type})
+   🎯 Role: ${this.getAgentRoleDescription(agent.type)}
+   📋 Capabilities: ${agent.config?.capabilities?.join(', ') || 'general automation'}
+   🆔 ID: ${agent.id}`).join('')}
+
+🔧 CRITICAL: USE CONCURRENT STREAMS FOR PARALLEL EXECUTION
+
+You MUST coordinate these agents using Claude's concurrent execution capabilities:
+
+1. **USE TASK TOOL FOR CONCURRENT AGENTS**: 
+   For each sub-agent, use the Task tool to spawn them with detailed prompts:
+   
+   Task("You are ${agent.name}. ${detailed_role_prompt}", "${agent.id}", "agent-${agent.type}")
+
+2. **PARALLEL EXECUTION PATTERN**:
+   Execute multiple agents simultaneously using the Task tool in a single response:
+   
+   \`\`\`
+   Task("Detailed prompt for Search Agent...", "search_agent", "researcher")
+   Task("Detailed prompt for Foundation Agent...", "foundation_agent", "coder") 
+   Task("Detailed prompt for Refinement Agent...", "refinement_agent", "optimizer")
+   Task("Detailed prompt for Ensemble Agent...", "ensemble_agent", "analyst")
+   Task("Detailed prompt for Validation Agent...", "validation_agent", "tester")
+   \`\`\`
+
+3. **DETAILED SUB-AGENT PROMPTS**:
+   Each Task call should include comprehensive instructions:
+   - Specific MLE-STAR role and responsibilities
+   - Required actions and deliverables
+   - Coordination requirements with other agents
+   - Output format specifications
+   - Use of --output-format stream-json for progress tracking
+
+4. **COORDINATION WORKFLOW**:
+   Phase 1: Search & Foundation (parallel)
+   Phase 2: Refinement & Optimization (depends on Phase 1)
+   Phase 3: Ensemble & Validation (depends on Phase 2)
+
+5. **OUTPUT MANAGEMENT**:
+   Instruct each agent to use appropriate Claude CLI flags:
+   - Use --print --output-format stream-json --verbose for real-time progress
+   - Coordinate results through file system and memory
+
+🎯 YOUR MISSION:
+1. Launch all ${agents.length} sub-agents using concurrent Task calls
+2. Provide detailed, specific prompts for each agent's MLE-STAR role
+3. Coordinate the workflow execution phases
+4. Monitor progress and provide updates
+5. Synthesize final results
+
+METHODOLOGY PHASES:
+${this.getMasterMethodologyGuide()}
+
+🚀 BEGIN: Start by deploying all sub-agents with detailed prompts using the Task tool for concurrent execution. Each agent should receive comprehensive instructions for their specific MLE-STAR role.`;
+    }
+    /**
+     * Get agent role description for coordination
+     */
+    getAgentRoleDescription(agentType) {
+        const roles = {
+            researcher: 'Web Search & Foundation Discovery - Find state-of-the-art approaches',
+            coder: 'Model Implementation & Training Pipeline - Build foundation models',
+            optimizer: 'Performance Tuning & Architecture Refinement - Optimize models',
+            analyst: 'Ensemble Methods & Meta-Learning - Combine multiple approaches',
+            tester: 'Validation & Debugging - Ensure quality and performance',
+            coordinator: 'Workflow Orchestration - Manage overall pipeline'
+        };
+        return roles[agentType] || 'Specialized automation task execution';
+    }
+    /**
+     * Get comprehensive methodology guide for master coordinator
+     */
+    getMasterMethodologyGuide() {
+        return `
+PHASE 1 - SEARCH & FOUNDATION (Parallel):
+🔬 Search Agent: Research ML approaches, algorithms, and best practices
+💻 Foundation Agent: Implement baseline models and training infrastructure
+
+PHASE 2 - REFINEMENT (Sequential, depends on Phase 1):
+⚡ Refinement Agent: Optimize models, tune hyperparameters, improve performance
+
+PHASE 3 - ENSEMBLE & VALIDATION (Parallel, depends on Phase 2):
+🏛️ Ensemble Agent: Combine models, implement voting/stacking strategies
+🧪 Validation Agent: Test, debug, validate performance, generate reports
+
+COORDINATION KEY POINTS:
+- Use shared file system for intermediate results
+- Maintain communication through progress updates
+- Each phase builds on previous phases
+- Final deliverable: Production-ready ML pipeline`;
+    }
+    /**
+     * Get agent position in MLE-STAR pipeline
+     */
+    getAgentPositionInPipeline(agentType) {
+        const positions = {
+            researcher: 'Phase 1: Search & Foundation Discovery (Parallel with Foundation)',
+            coder: 'Phase 1: Foundation Model Building (Parallel with Search)',
+            optimizer: 'Phase 2: Refinement & Optimization (Sequential, depends on Phase 1)',
+            analyst: 'Phase 3: Ensemble & Meta-Learning (Parallel with Validation)',
+            tester: 'Phase 3: Validation & Debugging (Parallel with Ensemble)',
+            coordinator: 'All Phases: Workflow Orchestration & Coordination'
+        };
+        return positions[agentType] || 'Specialized task execution';
+    }
+    /**
+     * Get coordination partners for agent type
+     */
+    getCoordinationPartners(agentType) {
+        const partners = {
+            researcher: 'Foundation Agent (parallel), Refinement Agent (handoff)',
+            coder: 'Search Agent (parallel), Refinement Agent (handoff)',
+            optimizer: 'Search & Foundation Agents (input), Ensemble & Validation Agents (handoff)',
+            analyst: 'Refinement Agent (input), Validation Agent (parallel)',
+            tester: 'All previous agents (validation), Ensemble Agent (parallel)',
+            coordinator: 'All agents (orchestration and monitoring)'
+        };
+        return partners[agentType] || 'Other workflow agents as needed';
+    }
+    /**
+     * Get methodology guidance for agent type
+     */
+    getMethodologyGuidance(agentType) {
+        const guidance = {
+            researcher: `SEARCH PHASE - Web Research & Foundation Discovery:
+- Search for state-of-the-art ML approaches for the problem domain
+- Find winning Kaggle solutions and benchmark results
+- Identify promising model architectures and techniques
+- Document implementation examples and model cards
+- Focus on proven, recent approaches with good performance`,
+            coder: `FOUNDATION PHASE - Initial Model Building:
+- Analyze dataset characteristics and problem type
+- Implement baseline models based on research findings
+- Create robust preprocessing pipelines
+- Build modular, testable code components
+- Establish performance baselines for comparison`,
+            optimizer: `REFINEMENT PHASE - Targeted Component Optimization:
+- Perform ablation analysis to identify high-impact components
+- Focus deep optimization on most impactful pipeline elements
+- Use iterative improvement with structured feedback
+- Implement advanced feature engineering techniques
+- Optimize hyperparameters systematically`,
+            architect: `ENSEMBLE PHASE - Intelligent Model Combination:
+- Create sophisticated ensemble strategies beyond simple averaging
+- Implement stacking with meta-learners
+- Use dynamic weighting and mixture of experts
+- Apply Bayesian model averaging where appropriate
+- Optimize ensemble composition for maximum performance`,
+            tester: `VALIDATION PHASE - Comprehensive Testing & Debugging:
+- Implement rigorous cross-validation strategies
+- Detect and prevent data leakage
+- Perform error analysis and debugging
+- Validate model robustness and generalization
+- Ensure production readiness with quality checks`,
+            coordinator: `ORCHESTRATION PHASE - Workflow Management:
+- Coordinate between all agents and phases
+- Monitor progress and performance metrics
+- Manage resource allocation and scheduling
+- Handle error recovery and workflow adaptation
+- Prepare final deployment and documentation`
+        };
+        return guidance[agentType] || 'Focus on your specialized capabilities and coordinate with other agents.';
+    }
+    /**
+     * Execute workflow tasks with dependency management
+     */
+    async executeWorkflowTasks(workflow) {
+        const { tasks, dependencies = {} } = workflow;
+        let completedTasks = 0;
+        let failedTasks = 0;
+        const totalTasks = tasks.length;
+        // Task status tracking
+        const taskStatuses = new Map();
+        tasks.forEach(task => {
+            taskStatuses.set(task.id, {
+                name: task.name || task.id,
+                status: 'pending',
+                agent: task.assignTo,
+                startTime: null,
+                endTime: null,
+                summary: ''
+            });
+        });
+        // Create task execution plan based on dependencies
+        const executionPlan = this.createExecutionPlan(tasks, dependencies);
+        console.log(`📋 Executing ${totalTasks} tasks in ${executionPlan.length} phases...`);
+        console.log();
+        // Note: Concurrent display disabled in favor of interactive-style stream processing
+        let concurrentDisplay = null;
+        // if (this.options.nonInteractive && this.options.outputFormat === 'stream-json') {
+        //   const { createConcurrentDisplay } = await import('./concurrent-display.js');
+        //   
+        //   // Get all agents and their tasks
+        //   const agentTasks = workflow.agents?.map(agent => ({
+        //     id: agent.id,
+        //     name: agent.name,
+        //     type: agent.type,
+        //     tasks: tasks.filter(t => t.assignTo === agent.id).map(t => t.name)
+        //   })) || [];
+        //   
+        //   concurrentDisplay = createConcurrentDisplay(agentTasks);
+        //   concurrentDisplay.start();
+        //   
+        //   // Store reference for stream processors
+        //   this.concurrentDisplay = concurrentDisplay;
+        // }
+        // Execute tasks phase by phase
+        for (const [phaseIndex, phaseTasks] of executionPlan.entries()) {
+            this.currentPhase = `Phase ${phaseIndex + 1}`;
+            // Show regular task board or update concurrent display
+            if (!concurrentDisplay) {
+                if (this.options.logLevel === 'quiet') {
+                    console.log(`\n🔄 Phase ${phaseIndex + 1}: Running ${phaseTasks.length} tasks`);
+                }
+                else {
+                    console.log(`\n🔄 Phase ${phaseIndex + 1}: ${phaseTasks.length} concurrent tasks`);
+                }
+                this.displayTaskBoard(taskStatuses, phaseTasks);
+            }
+            // Mark tasks as in-progress
+            phaseTasks.forEach(task => {
+                const status = taskStatuses.get(task.id);
+                status.status = 'in-progress';
+                status.startTime = Date.now();
+            });
+            // Execute tasks in this phase (potentially in parallel)
+            const phasePromises = phaseTasks.map(async (task) => {
+                const taskStatus = taskStatuses.get(task.id);
+                try {
+                    // Show task starting
+                    console.log(`\n  🚀 Starting: ${task.name || task.id}`);
+                    console.log(`     Agent: ${task.assignTo}`);
+                    console.log(`     Description: ${task.description?.substring(0, 80)}...`);
+                    const result = await this.executeTask(task, workflow);
+                    taskStatus.status = result.success ? 'completed' : 'failed';
+                    taskStatus.endTime = Date.now();
+                    taskStatus.summary = result.success ?
+                        `✅ Completed in ${this.formatDuration(result.duration)}` :
+                        `❌ Failed: ${result.error?.message || 'Unknown error'}`;
+                    return result;
+                }
+                catch (error) {
+                    taskStatus.status = 'failed';
+                    taskStatus.endTime = Date.now();
+                    taskStatus.summary = `❌ Error: ${error.message}`;
+                    throw error;
+                }
+            });
+            // Wait for all phase tasks to complete
+            const phaseResults = await Promise.allSettled(phasePromises);
+            // Process phase results
+            for (const [taskIndex, result] of phaseResults.entries()) {
+                const task = phaseTasks[taskIndex];
+                const taskStatus = taskStatuses.get(task.id);
+                if (result.status === 'fulfilled' && result.value.success) {
+                    completedTasks++;
+                    this.results.set(task.id, result.value);
+                }
+                else {
+                    failedTasks++;
+                    const error = result.status === 'rejected' ? result.reason : result.value.error;
+                    this.errors.push({
+                        type: 'task_execution',
+                        task: task.id,
+                        error: error.message || error,
+                        timestamp: new Date()
+                    });
+                    // Check if we should fail fast
+                    if (workflow.settings?.failurePolicy === 'fail-fast') {
+                        console.log(`\n🛑 Failing fast due to task failure`);
+                        break;
+                    }
+                }
+            }
+            // Show updated task board
+            if (!concurrentDisplay) {
+                console.log(`\n📊 Phase ${phaseIndex + 1} Complete:`);
+                this.displayTaskBoard(taskStatuses);
+            }
+            // Stop if fail-fast and we have failures
+            if (workflow.settings?.failurePolicy === 'fail-fast' && failedTasks > 0) {
+                break;
+            }
+        }
+        // Final summary
+        if (!concurrentDisplay) {
+            console.log(`\n📊 Final Workflow Summary:`);
+            this.displayTaskBoard(taskStatuses);
+        }
+        else {
+            // Stop concurrent display
+            concurrentDisplay.stop();
+            console.log(); // Add some space after display
+        }
+        return {
+            success: failedTasks === 0,
+            totalTasks,
+            completedTasks,
+            failedTasks,
+            executionId: this.executionId,
+            duration: Date.now() - this.startTime,
+            results: Object.fromEntries(this.results),
+            errors: this.errors
+        };
+    }
+    /**
+     * Display task board showing current status
+     */
+    displayTaskBoard(taskStatuses, highlightTasks = []) {
+        // In quiet mode, just show simple progress
+        if (this.options.logLevel === 'quiet') {
+            const totalTasks = taskStatuses.size;
+            const completedTasks = Array.from(taskStatuses.values()).filter(s => s.status === 'completed').length;
+            const activeTasks = Array.from(taskStatuses.values()).filter(s => s.status === 'in-progress').length;
+            console.log(`📊 Progress: ${completedTasks}/${totalTasks} completed, ${activeTasks} active`);
+            return;
+        }
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        const frameIndex = Math.floor(Date.now() / 100) % frames.length;
+        const spinner = frames[frameIndex];
+        console.log('\n╔═══════════════════════════════════════════════════════════════╗');
+        console.log('║                    🤖 CONCURRENT TASK STATUS                   ║');
+        console.log('╠═══════════════════════════════════════════════════════════════╣');
+        // Group by status
+        const statusGroups = {
+            'in-progress': [],
+            'completed': [],
+            'failed': [],
+            'pending': []
+        };
+        taskStatuses.forEach((status, taskId) => {
+            statusGroups[status.status].push({ taskId, ...status });
+        });
+        // Show in-progress tasks with animation
+        if (statusGroups['in-progress'].length > 0) {
+            console.log(`║ ${spinner} RUNNING (${statusGroups['in-progress'].length} agents):                                      ║`);
+            statusGroups['in-progress'].forEach(task => {
+                const duration = task.startTime ? this.formatDuration(Date.now() - task.startTime) : '';
+                const progress = this.getProgressBar(Date.now() - task.startTime, 60000); // 1 min expected
+                const agentIcon = this.getAgentIcon(task.agent);
+                console.log(`║   ${agentIcon} ${task.name.padEnd(25)} ${progress} ${duration.padStart(8)} ║`);
+            });
+        }
+        // Show completed tasks
+        if (statusGroups['completed'].length > 0) {
+            console.log(`║ ✅ COMPLETED (${statusGroups['completed'].length}):                                           ║`);
+            statusGroups['completed'].forEach(task => {
+                const duration = task.endTime && task.startTime ?
+                    this.formatDuration(task.endTime - task.startTime) : '';
+                console.log(`║   ✓ ${task.name.padEnd(35)} ${duration.padStart(10)} ║`);
+            });
+        }
+        // Show failed tasks
+        if (statusGroups['failed'].length > 0) {
+            console.log(`║ ❌ FAILED (${statusGroups['failed'].length}):                                              ║`);
+            statusGroups['failed'].forEach(task => {
+                const errorMsg = (task.summary || '').substring(0, 25);
+                console.log(`║   ✗ ${task.name.padEnd(25)} ${errorMsg.padEnd(20)} ║`);
+            });
+        }
+        // Show pending tasks count
+        if (statusGroups['pending'].length > 0) {
+            console.log(`║ ⏳ QUEUED: ${statusGroups['pending'].length} tasks waiting                                 ║`);
+        }
+        // Summary stats
+        const total = taskStatuses.size;
+        const completed = statusGroups['completed'].length;
+        const failed = statusGroups['failed'].length;
+        const progress = total > 0 ? Math.floor((completed + failed) / total * 100) : 0;
+        console.log('╠═══════════════════════════════════════════════════════════════╣');
+        console.log(`║ 📊 Progress: ${progress}% (${completed}/${total}) │ ⚡ Active: ${statusGroups['in-progress'].length} │ ❌ Failed: ${failed}  ║`);
+        console.log('╚═══════════════════════════════════════════════════════════════╝');
+    }
+    /**
+     * Get progress bar visualization
+     */
+    getProgressBar(elapsed, expected) {
+        const progress = Math.min(elapsed / expected, 1);
+        const filled = Math.floor(progress * 10);
+        const empty = 10 - filled;
+        return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+    }
+    /**
+     * Get agent icon based on type
+     */
+    getAgentIcon(agentId) {
+        const icons = {
+            'search': '🔍',
+            'foundation': '🏗️',
+            'refinement': '🔧',
+            'ensemble': '🎯',
+            'validation': '✅',
+            'coordinator': '🎮',
+            'researcher': '🔬',
+            'coder': '💻',
+            'optimizer': '⚡',
+            'architect': '🏛️',
+            'tester': '🧪'
+        };
+        // Extract agent type from ID
+        const type = agentId?.split('_')[0] || 'default';
+        return icons[type] || '🤖';
+    }
+    /**
+     * Execute a single task
+     */
+    async executeTask(task, workflow) {
+        const startTime = Date.now();
+        try {
+            // Store task execution in memory if hooks enabled
+            if (this.hooksEnabled) {
+                await this.executeHook('notify', {
+                    message: `Starting task: ${task.name || task.id}`,
+                    sessionId: this.sessionId
+                });
+            }
+            if (this.options.nonInteractive && this.options.outputFormat === 'stream-json') {
+                console.log(`\n● ${task.name || task.id} - Starting Execution`);
+                console.log(`  ⎿  ${task.description}`);
+                console.log(`  ⎿  Agent: ${task.assignTo}`);
+            }
+            else {
+                console.log(`    🔄 Executing: ${task.description}`);
+            }
+            // For demonstration/testing mode (when Claude integration is disabled)
+            // we simulate successful task completion
+            if (!this.options.enableClaude) {
+                // Simulate variable execution time
+                const executionTime = Math.min(1000 + Math.random() * 3000, // 1-4 seconds simulation
+                task.timeout || 30000);
+                await new Promise(resolve => setTimeout(resolve, executionTime));
+                // Simulate successful completion for demo/testing
+                const result = {
+                    success: true,
+                    taskId: task.id,
+                    duration: Date.now() - startTime,
+                    output: {
+                        status: 'completed',
+                        agent: task.assignTo,
+                        executionTime: Date.now() - startTime,
+                        metadata: {
+                            timestamp: new Date().toISOString(),
+                            executionId: this.executionId,
+                            mode: 'simulation'
+                        }
+                    }
+                };
+                // Store result in memory
+                if (this.hooksEnabled) {
+                    await this.storeTaskResult(task.id, result.output);
+                }
+                return result;
+            }
+            else {
+                // When Claude integration is enabled, delegate to actual Claude instance
+                // Check if we have a master coordinator (interactive mode)
+                const masterCoordinator = this.claudeInstances.get('master-coordinator');
+                if (masterCoordinator && !this.options.nonInteractive) {
+                    // Interactive mode: All tasks are coordinated by the master coordinator
+                    console.log(`    🎯 Task delegated to Master Coordinator: ${task.description}`);
+                    // In interactive mode, the master coordinator handles all tasks
+                    // We just wait for the master coordinator process to complete
+                    const completionPromise = new Promise((resolve, reject) => {
+                        masterCoordinator.process.on('exit', (code) => {
+                            if (code === 0) {
+                                resolve({ success: true, code });
+                            }
+                            else {
+                                reject(new Error(`Master coordinator exited with code ${code}`));
+                            }
+                        });
+                        masterCoordinator.process.on('error', (err) => {
+                            reject(err);
+                        });
+                    });
+                    // For interactive mode, we use a longer timeout since user interaction is involved
+                    const timeout = Math.max(this.options.timeout, 1800000); // 30 minutes minimum for interactive
+                    const timeoutPromise = new Promise((_, reject) => {
+                        setTimeout(() => reject(new Error('Interactive session timeout')), timeout);
+                    });
+                    try {
+                        await Promise.race([completionPromise, timeoutPromise]);
+                        const result = {
+                            success: true,
+                            taskId: task.id,
+                            duration: Date.now() - startTime,
+                            output: {
+                                status: 'completed',
+                                agent: 'master-coordinator',
+                                executionTime: Date.now() - startTime,
+                                metadata: {
+                                    timestamp: new Date().toISOString(),
+                                    executionId: this.executionId,
+                                    mode: 'interactive-coordination'
+                                }
+                            }
+                        };
+                        // Store result in memory
+                        if (this.hooksEnabled) {
+                            await this.storeTaskResult(task.id, result.output);
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        throw new Error(`Task execution failed: ${error.message}`);
+                    }
+                }
+                // Non-interactive mode or no master coordinator: use individual Claude instances
+                const claudeInstance = this.claudeInstances.get(task.assignTo);
+                if (!claudeInstance) {
+                    // If no pre-spawned instance, create one for this task
+                    const agent = workflow.agents.find(a => a.id === task.assignTo);
+                    if (!agent) {
+                        throw new Error(`No agent definition found for: ${task.assignTo}`);
+                    }
+                    // Create task-specific prompt
+                    const taskPrompt = this.createTaskPrompt(task, agent, workflow);
+                    // Check if we should chain from a previous task
+                    let chainOptions = {};
+                    if (this.enableChaining && this.options.outputFormat === 'stream-json' && task.depends?.length > 0) {
+                        // Get the output stream from the last dependency
+                        const lastDependency = task.depends[task.depends.length - 1];
+                        const dependencyStream = this.taskOutputStreams.get(lastDependency);
+                        if (dependencyStream) {
+                            console.log(`    🔗 Enabling stream chaining from ${lastDependency} to ${task.id}`);
+                            chainOptions.inputStream = dependencyStream;
+                        }
+                    }
+                    // Spawn Claude instance for this specific task
+                    const taskClaudeProcess = await this.spawnClaudeInstance(agent, taskPrompt, chainOptions);
+                    // Store the output stream for potential chaining
+                    if (this.enableChaining && this.options.outputFormat === 'stream-json' && taskClaudeProcess.stdout) {
+                        this.taskOutputStreams.set(task.id, taskClaudeProcess.stdout);
+                    }
+                    // Store the instance
+                    this.claudeInstances.set(agent.id, {
+                        process: taskClaudeProcess,
+                        agent: agent,
+                        status: 'active',
+                        startTime: Date.now(),
+                        taskId: task.id
+                    });
+                    // Wait for task completion or timeout
+                    // Use longer timeout for ML tasks
+                    const baseTimeout = this.options.timeout || 60000;
+                    const isMLTask = task.type?.toLowerCase().includes('ml') ||
+                        task.type?.toLowerCase().includes('model') ||
+                        task.type?.toLowerCase().includes('search') ||
+                        task.type?.toLowerCase().includes('analysis') ||
+                        this.options.workflowType === 'ml';
+                    const timeout = task.timeout || (isMLTask ? Math.max(baseTimeout, 300000) : baseTimeout); // Min 5 minutes for ML tasks
+                    if (this.options.logLevel === 'debug' || this.options.verbose) {
+                        console.log(`    ⏱️  Timeout: ${this.formatDuration(timeout)} (Base: ${this.formatDuration(baseTimeout)}, ML Task: ${isMLTask})`);
+                    }
+                    const completionPromise = new Promise((resolve, reject) => {
+                        taskClaudeProcess.on('exit', (code) => {
+                            if (code === 0) {
+                                resolve({ success: true, code });
+                            }
+                            else {
+                                reject(new Error(`Process exited with code ${code}`));
+                            }
+                        });
+                        taskClaudeProcess.on('error', (err) => {
+                            reject(err);
+                        });
+                    });
+                    const timeoutPromise = new Promise((_, reject) => {
+                        // Use a much longer timeout for ML tasks since Claude is actively working
+                        const actualTimeout = isMLTask ? Math.max(timeout, 600000) : timeout; // 10 min minimum for ML
+                        setTimeout(() => reject(new Error('Task timeout')), actualTimeout);
+                    });
+                    try {
+                        await Promise.race([completionPromise, timeoutPromise]);
+                        const result = {
+                            success: true,
+                            taskId: task.id,
+                            duration: Date.now() - startTime,
+                            output: {
+                                status: 'completed',
+                                agent: task.assignTo,
+                                executionTime: Date.now() - startTime,
+                                metadata: {
+                                    timestamp: new Date().toISOString(),
+                                    executionId: this.executionId,
+                                    mode: 'claude-task-execution'
+                                }
+                            }
+                        };
+                        // Store result in memory
+                        if (this.hooksEnabled) {
+                            await this.storeTaskResult(task.id, result.output);
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+                else {
+                    // Use existing Claude instance
+                    // In a full implementation, this would send the task to the running instance
+                    // For now, we'll spawn a new instance per task for simplicity
+                    const agent = claudeInstance.agent;
+                    const taskPrompt = this.createTaskPrompt(task, agent, workflow);
+                    // Check if we should chain from a previous task
+                    let chainOptions = {};
+                    if (this.enableChaining && this.options.outputFormat === 'stream-json' && task.depends?.length > 0) {
+                        // Get the output stream from the last dependency
+                        const lastDependency = task.depends[task.depends.length - 1];
+                        const dependencyStream = this.taskOutputStreams.get(lastDependency);
+                        if (dependencyStream) {
+                            console.log(`    🔗 Enabling stream chaining from ${lastDependency} to ${task.id}`);
+                            chainOptions.inputStream = dependencyStream;
+                        }
+                    }
+                    // For now, spawn a new instance for each task
+                    const taskClaudeProcess = await this.spawnClaudeInstance(agent, taskPrompt, chainOptions);
+                    // Store the output stream for potential chaining
+                    if (this.enableChaining && this.options.outputFormat === 'stream-json' && taskClaudeProcess.stdout) {
+                        this.taskOutputStreams.set(task.id, taskClaudeProcess.stdout);
+                    }
+                    // Wait for completion
+                    // Use longer timeout for ML tasks
+                    const baseTimeout = this.options.timeout || 60000;
+                    const isMLTask = task.type?.toLowerCase().includes('ml') ||
+                        task.type?.toLowerCase().includes('model') ||
+                        task.type?.toLowerCase().includes('search') ||
+                        task.type?.toLowerCase().includes('analysis') ||
+                        this.options.workflowType === 'ml';
+                    const timeout = task.timeout || (isMLTask ? Math.max(baseTimeout, 300000) : baseTimeout); // Min 5 minutes for ML tasks
+                    if (this.options.logLevel === 'debug' || this.options.verbose) {
+                        console.log(`    ⏱️  Timeout: ${this.formatDuration(timeout)} (Base: ${this.formatDuration(baseTimeout)}, ML Task: ${isMLTask})`);
+                    }
+                    const completionPromise = new Promise((resolve, reject) => {
+                        taskClaudeProcess.on('exit', (code) => {
+                            if (code === 0) {
+                                resolve({ success: true, code });
+                            }
+                            else {
+                                reject(new Error(`Process exited with code ${code}`));
+                            }
+                        });
+                        taskClaudeProcess.on('error', (err) => {
+                            reject(err);
+                        });
+                    });
+                    const timeoutPromise = new Promise((_, reject) => {
+                        // Use a much longer timeout for ML tasks since Claude is actively working
+                        const actualTimeout = isMLTask ? Math.max(timeout, 600000) : timeout; // 10 min minimum for ML
+                        setTimeout(() => reject(new Error('Task timeout')), actualTimeout);
+                    });
+                    try {
+                        await Promise.race([completionPromise, timeoutPromise]);
+                        const result = {
+                            success: true,
+                            taskId: task.id,
+                            duration: Date.now() - startTime,
+                            output: {
+                                status: 'completed',
+                                agent: task.assignTo,
+                                executionTime: Date.now() - startTime,
+                                metadata: {
+                                    timestamp: new Date().toISOString(),
+                                    executionId: this.executionId,
+                                    mode: 'claude-task-execution'
+                                }
+                            }
+                        };
+                        // Store result in memory
+                        if (this.hooksEnabled) {
+                            await this.storeTaskResult(task.id, result.output);
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                taskId: task.id,
+                duration: Date.now() - startTime,
+                error: error
+            };
+        }
+    }
+    /**
+     * Create execution plan based on task dependencies
+     */
+    createExecutionPlan(tasks, dependencies) {
+        const taskMap = new Map(tasks.map(task => [task.id, task]));
+        const completed = new Set();
+        const phases = [];
+        while (completed.size < tasks.length) {
+            const readyTasks = tasks.filter(task => {
+                if (completed.has(task.id))
+                    return false;
+                const deps = task.depends || dependencies[task.id] || [];
+                return deps.every(dep => completed.has(dep));
+            });
+            if (readyTasks.length === 0) {
+                throw new Error('Circular dependency detected or invalid dependencies');
+            }
+            phases.push(readyTasks);
+            readyTasks.forEach(task => completed.add(task.id));
+        }
+        return phases;
+    }
+    /**
+     * Execute a hook command
+     */
+    async executeHook(hookType, params) {
+        try {
+            const { execSync } = await import('child_process');
+            let hookCommand = `npx claude-flow@alpha hooks ${hookType}`;
+            if (params.description) {
+                hookCommand += ` --description "${params.description}"`;
+            }
+            if (params.file) {
+                hookCommand += ` --file "${params.file}"`;
+            }
+            if (params.taskId) {
+                hookCommand += ` --task-id "${params.taskId}"`;
+            }
+            if (params.sessionId) {
+                hookCommand += ` --session-id "${params.sessionId}"`;
+            }
+            if (params.message) {
+                hookCommand += ` --message "${params.message}"`;
+            }
+            execSync(hookCommand, { stdio: 'pipe' });
+        }
+        catch (error) {
+            // Hooks are optional, don't fail the workflow if they fail
+            console.debug(`Hook ${hookType} failed:`, error.message);
+        }
+    }
+    /**
+     * Store task result in memory
+     */
+    async storeTaskResult(taskId, result) {
+        try {
+            const { execSync } = await import('child_process');
+            const resultJson = JSON.stringify(result);
+            execSync(`npx claude-flow@alpha memory store "workflow/${this.executionId}/${taskId}" '${resultJson}'`, {
+                stdio: 'pipe'
+            });
+        }
+        catch (error) {
+            console.debug(`Failed to store task result for ${taskId}:`, error.message);
+        }
+    }
+    /**
+     * Validate workflow definition
+     */
+    validateWorkflow(workflow) {
+        if (!workflow.name) {
+            throw new Error('Workflow name is required');
+        }
+        if (!workflow.tasks || workflow.tasks.length === 0) {
+            throw new Error('Workflow must contain at least one task');
+        }
+        // Validate task structure
+        for (const task of workflow.tasks) {
+            if (!task.id || !task.type || !task.description) {
+                throw new Error(`Task ${task.id || 'unknown'} is missing required fields`);
+            }
+        }
+        // Validate agent assignments
+        if (workflow.agents) {
+            const agentIds = new Set(workflow.agents.map(a => a.id));
+            for (const task of workflow.tasks) {
+                if (task.assignTo && !agentIds.has(task.assignTo)) {
+                    throw new Error(`Task ${task.id} assigned to unknown agent: ${task.assignTo}`);
+                }
+            }
+        }
+    }
+    /**
+     * Apply variable substitutions to workflow
+     */
+    applyVariables(workflow, variables) {
+        const allVariables = { ...workflow.variables, ...variables };
+        const workflowStr = JSON.stringify(workflow);
+        // Simple variable substitution
+        let processedStr = workflowStr;
+        for (const [key, value] of Object.entries(allVariables)) {
+            const pattern = new RegExp(`\\$\\{${key}\\}`, 'g');
+            processedStr = processedStr.replace(pattern, value);
+        }
+        return JSON.parse(processedStr);
+    }
+    /**
+     * Cleanup Claude instances
+     */
+    async cleanupClaudeInstances() {
+        if (this.claudeInstances.size === 0)
+            return;
+        console.log('🧹 Cleaning up Claude instances...');
+        for (const [agentId, instance] of this.claudeInstances.entries()) {
+            try {
+                if (instance.process && !instance.process.killed) {
+                    instance.process.kill('SIGTERM');
+                    // Wait for graceful shutdown, then force kill if needed
+                    setTimeout(() => {
+                        if (!instance.process.killed) {
+                            instance.process.kill('SIGKILL');
+                        }
+                    }, 5000);
+                }
+                console.log(`  ✅ Cleaned up ${instance.agent.name}`);
+            }
+            catch (error) {
+                console.error(`  ❌ Error cleaning up ${instance.agent.name}:`, error.message);
+            }
+        }
+        this.claudeInstances.clear();
+    }
+    /**
+     * Format duration in human readable format
+     */
+    formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+        }
+        else if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        else {
+            return `${seconds}s`;
+        }
+    }
+}
+/**
+ * Load workflow from file
+ */
+export async function loadWorkflowFromFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (filePath.endsWith('.json')) {
+            return JSON.parse(content);
+        }
+        else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+            // For now, just return error - YAML support can be added later
+            throw new Error('YAML workflows not yet supported');
+        }
+        else {
+            throw new Error('Unsupported workflow file format. Use .json or .yaml');
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to load workflow: ${error.message}`);
+    }
+}
+/**
+ * Get default MLE-STAR workflow path
+ */
+export function getMLEStarWorkflowPath() {
+    return join(process.cwd(), 'src', 'cli', 'simple-commands', 'templates', 'mle-star-workflow.json');
+}
+//# sourceMappingURL=automation-executor.js.map