claude-flow-novice 2.0.4 → 2.0.5

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

@@ -4,371 +4,469 @@
  * 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 } from "path";
-import { printSuccess, printError } from "../utils.js";
+ */
+
+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)}`;
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
+
 /**
  * WorkflowExecutor - Core class for executing automation workflows
- */ export class WorkflowExecutor {
-    /**
-   * 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;
-        }
+ */
+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
     }
-    /**
-   * 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');
+
+    // 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) {
-            // 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
-                });
-                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(`🖥️  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;
-        }
+   */
+  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(agent1, 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 ${agent1.name}: claude ${flagsDisplay} "${displayPrompt}"`);
-        } else if (this.options.logLevel !== 'quiet') {
-            console.log(`    🚀 Starting ${agent1.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 ${agent1.name}`);
-            options.inputStream.pipe(claudeProcess.stdin);
+   */
+  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');
         }
-        // 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(agent1.name, this.getAgentIcon(agent1.id), {
-                verbose: this.options.logLevel === 'debug',
-                logLevel: this.options.logLevel,
-                taskId: agent1.taskId,
-                agentId: agent1.id,
-                display: null
-            });
-            // 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(`    ❌ [${agent1.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());
-            });
+      }
+    }
+
+    // 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}`);
         }
-        // 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 ${agent1.name}:`, error.message);
-            this.errors.push({
-                type: 'claude_instance_error',
-                agent: agent1.id,
-                error: error.message,
-                timestamp: new Date()
-            });
-        });
-        claudeProcess.on('exit', (code)=>{
-            const instance = this.claudeInstances.get(agent1.id);
-            if (instance) {
-                instance.status = code === 0 ? 'completed' : 'failed';
-                instance.exitCode = code;
-                instance.endTime = Date.now();
-            }
-        });
-        return claudeProcess;
+      });
+    } 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(agent1, 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],
-                agent: `${this.getAgentIcon(agent1.id)} ${agent1.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(`    [${agent1.name}] 🔧 Using tool: ${event.name}`);
-                    break;
-                case 'message':
-                    console.log(`    [${agent1.name}] 💬 ${event.content}`);
-                    break;
-                case 'completion':
-                    console.log(`    [${agent1.name}] ✅ Task completed`);
-                    break;
-                case 'error':
-                    console.error(`    [${agent1.name}] ❌ Error: ${event.error}`);
-                    break;
-                default:
-                    // Log other events in debug mode
-                    if (this.options.logLevel === 'debug') {
-                        console.log(`    [${agent1.name}] ${event.type}: ${JSON.stringify(event)}`);
-                    }
-            }
-        }
+   */
+  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;
-        }
+   */
+  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] || '📌';
-    }
-    /**
+   */
+  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, agent1, 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
+   */
+  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 };
 
-You are the **${agent1.name}** (${agent1.type}) in a coordinated MLE-STAR automation workflow.
+      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(agent1.type)}
+${this.getAgentRoleDescription(agent.type)}
 
 🎯 AGENT CAPABILITIES:
-${agent1.config?.capabilities?.join(', ') || 'general automation'}
+${agent.config?.capabilities?.join(', ') || 'general automation'}
 
 🔬 MLE-STAR METHODOLOGY FOCUS:
-${this.getMethodologyGuidance(agent1.type)}
+${this.getMethodologyGuidance(agent.type)}
 
 🔧 COORDINATION REQUIREMENTS:
 1. **HOOKS INTEGRATION** (CRITICAL):
@@ -377,20 +475,20 @@ ${this.getMethodologyGuidance(agent1.type)}
    - 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/${agent1.id}/findings" "[your_findings]"\`
-   - Store results: \`npx claude-flow@alpha memory store "agent/${agent1.id}/results" "[your_results]"\`
+   - 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: ${agent1.id}
+   - Agent ID: ${agent.id}
 
 4. **WORKFLOW PIPELINE AWARENESS**:
-   - Your position: ${this.getAgentPositionInPipeline(agent1.type)}
-   - Coordinate with: ${this.getCoordinationPartners(agent1.type)}
-   - File naming: Use \`${agent1.id}_[component].[ext]\` convention
+   - 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
@@ -414,30 +512,33 @@ ${this.getMethodologyGuidance(agent1.type)}
 - Ready for next pipeline phase
 
 Begin execution now with the hooks pre-task command.`;
-        } else {
-            // Fallback to full agent prompt
-            return this.createAgentPrompt(agent1);
-        }
+    } else {
+      // Fallback to full agent prompt
+      return this.createAgentPrompt(agent);
     }
-    /**
+  }
+
+  /**
    * Create agent-specific Claude prompt
-   */ createAgentPrompt(agent1) {
-        const { config } = agent1;
-        const capabilities = config?.capabilities?.join(', ') || 'general automation';
-        return `You are the ${agent1.name} in a coordinated MLE-STAR automation workflow.
+   */
+  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: ${agent1.type.toUpperCase()}
+🎯 AGENT ROLE: ${agent.type.toUpperCase()}
 📋 CAPABILITIES: ${capabilities}
-🆔 AGENT ID: ${agent1.id}
+🆔 AGENT ID: ${agent.id}
 
 CRITICAL COORDINATION REQUIREMENTS:
 1. HOOKS: Use claude-flow-novice 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 '${agent1.id}'" when complete
+   - 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/${agent1.id}/[key]' '[value]'" for important data
+   - 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:
@@ -448,24 +549,27 @@ AGENT-SPECIFIC CONFIGURATION:
 ${JSON.stringify(config, null, 2)}
 
 MLE-STAR METHODOLOGY FOCUS:
-${this.getMethodologyGuidance(agent1.type)}
+${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: ${agent1.id}_[component].[ext]
+- 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
+   */
+  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. 
 
@@ -475,11 +579,15 @@ You are the MASTER COORDINATOR for a comprehensive MLE-STAR (Machine Learning En
 🔄 SESSION ID: ${this.sessionId}
 
 🤖 SUB-AGENTS TO COORDINATE (${agents.length} total):
-${agents.map((agent1, index)=>`
-${index + 1}. ${agent1.name} (${agent1.type})
-   🎯 Role: ${this.getAgentRoleDescription(agent1.type)}
-   📋 Capabilities: ${agent1.config?.capabilities?.join(', ') || 'general automation'}
-   🆔 ID: ${agent1.id}`).join('')}
+${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
 
@@ -530,24 +638,28 @@ 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';
-    }
-    /**
+   */
+  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 `
+   */
+  getMasterMethodologyGuide() {
+    return `
 PHASE 1 - SEARCH & FOUNDATION (Parallel):
 🔬 Search Agent: Research ML approaches, algorithms, and best practices
 💻 Foundation Agent: Implement baseline models and training infrastructure
@@ -564,796 +676,928 @@ COORDINATION KEY POINTS:
 - 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';
-    }
-    /**
+   */
+  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';
-    }
-    /**
+   */
+  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:
+   */
+  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:
+
+      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:
+
+      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:
+
+      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:
+
+      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:
+
+      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.';
-    }
-    /**
+- 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;
-            }
+   */
+  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;
         }
-        // Final summary
-        if (!concurrentDisplay) {
-            console.log(`\n📊 Final Workflow Summary:`);
-            this.displayTaskBoard(taskStatuses);
+      });
+
+      // 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 {
-            // Stop concurrent display
-            concurrentDisplay.stop();
-            console.log(); // Add some space after display
+          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;
+          }
         }
-        return {
-            success: failedTasks === 0,
-            totalTasks,
-            completedTasks,
-            failedTasks,
-            executionId: this.executionId,
-            duration: Date.now() - this.startTime,
-            results: Object.fromEntries(this.results),
-            errors: this.errors
-        };
+      }
+
+      // 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: []
+   */
+  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',
+            },
+          },
         };
-        taskStatuses.forEach((status, taskId)=>{
-            statusGroups[status.status].push({
-                taskId,
-                ...status
+
+        // 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}`));
+              }
             });
-        });
-        // 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)} ║`);
+
+            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}`);
+          }
         }
-        // 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)} ║`);
+
+        // 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}`));
+              }
             });
-        }
-        // 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)} ║`);
+
+            taskClaudeProcess.on('error', (err) => {
+              reject(err);
             });
-        }
-        // 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
+          });
+
+          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.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}`);
+              await this.storeTaskResult(task.id, result.output);
             }
-            // 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, 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 agent1 = workflow.agents.find((a)=>a.id === task.assignTo);
-                    if (!agent1) {
-                        throw new Error(`No agent definition found for: ${task.assignTo}`);
-                    }
-                    // Create task-specific prompt
-                    const taskPrompt = this.createTaskPrompt(task, agent1, 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(agent1, 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(agent1.id, {
-                        process: taskClaudeProcess,
-                        agent: agent1,
-                        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 agent1 = claudeInstance.agent;
-                    const taskPrompt = this.createTaskPrompt(task, agent1, 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(agent1, 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;
-                    }
-                }
+
+            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;
             }
-        } catch (error) {
-            return {
-                success: false,
-                taskId: task.id,
-                duration: Date.now() - startTime,
-                error: error
+          }
+
+          // 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;
+   */
+  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);
-        }
+   */
+  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);
-        }
+   */
+  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}`);
-                }
-            }
+   */
+  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);
+   */
+  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);
+   */
+  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);
         }
-        this.claudeInstances.clear();
+
+        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`;
-        }
-    }
-    constructor(options = {}){
-        this.options = {
-            enableClaude: false,
-            nonInteractive: false,
-            outputFormat: 'text',
-            maxConcurrency: 3,
-            timeout: 3600000,
-            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');
+   */
+  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}`);
+ */
+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');
+ */
+export function getMLEStarWorkflowPath() {
+  return join(
+    process.cwd(),
+    'src',
+    'cli',
+    'simple-commands',
+    'templates',
+    'mle-star-workflow.json',
+  );
 }