claude-flow-novice 2.0.3 → 2.0.4

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

@@ -4,469 +4,371 @@
  * This module provides the core infrastructure for executing automation
  * workflows with Claude CLI integration, while preserving existing
  * swarm and hive-mind functionality.
- */
-
-import { promises as fs } from 'fs';
-import { spawn } from 'child_process';
-import { join, dirname } from 'path';
-import { printSuccess, printError, printWarning } from '../utils.js';
-
+ */ import { promises as fs } from "fs";
+import { spawn } from "child_process";
+import { join } from "path";
+import { printSuccess, printError } 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 {
-  constructor(options = {}) {
-    this.options = {
-      enableClaude: false,
-      nonInteractive: false,
-      outputFormat: 'text',
-      maxConcurrency: 3,
-      timeout: 3600000, // 1 hour default
-      logLevel: 'info',
-      ...options,
-    };
-
-    // Increase timeout for ML workflows
-    if (options.workflowType === 'ml' || options.workflowName?.toLowerCase().includes('mle')) {
-      this.options.timeout = 7200000; // 2 hours for ML workflows
-    }
-
-    // Execution state
-    this.executionId = generateId('workflow-exec');
-    this.startTime = Date.now();
-    this.activeTasks = new Map();
-    this.claudeInstances = new Map();
-    this.results = new Map();
-    this.errors = [];
-    this.currentWorkflow = null;
-
-    // Stream chaining support
-    this.taskOutputStreams = new Map(); // Store output streams for chaining
-    this.enableChaining = options.enableChaining !== false; // Default to true
-
-    // Hooks integration
-    this.hooksEnabled = true;
-    this.sessionId = generateId('automation-session');
-  }
-
-  /**
+ */ 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') {
+   */ 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();
-            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');
-          }
+            // 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;
         }
-      }
-
-      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();
+   */ 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
+                });
+                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(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');
+   */ 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 ${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}`);
+        // 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}`);
         }
-      });
-    } 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());
-      });
+        // 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);
+        }
+        // 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());
+            });
+        }
+        // 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;
     }
-    // Note: In interactive mode, stdio is inherited so Claude handles its own I/O
-
-    // Handle process events
-    claudeProcess.on('error', (error) => {
-      console.error(`❌ Claude instance error for ${agent.name}:`, error.message);
-      this.errors.push({
-        type: 'claude_instance_error',
-        agent: agent.id,
-        error: error.message,
-        timestamp: new Date(),
-      });
-    });
-
-    claudeProcess.on('exit', (code) => {
-      const instance = this.claudeInstances.get(agent.id);
-      if (instance) {
-        instance.status = code === 0 ? 'completed' : 'failed';
-        instance.exitCode = code;
-        instance.endTime = Date.now();
-      }
-    });
-
-    return claudeProcess;
-  }
-
-  /**
+    /**
    * Handle Claude stream events
-   */
-  handleClaudeStreamEvent(agent, event) {
-    if (this.options.outputFormat === 'stream-json') {
-      // Create concise formatted JSON with summary
-      const summary = this.getEventSummary(event);
-      const icon = this.getEventIcon(event.type);
-
-      // Simplified output for better readability
-      const output = {
-        t: new Date().toISOString().split('T')[1].split('.')[0], // HH:MM:SS
-        agent: `${this.getAgentIcon(agent.id)} ${agent.name}`,
-        phase: this.currentPhase,
-        event: `${icon} ${summary}`,
-      };
-
-      // Add relevant details based on event type
-      if (event.type === 'tool_use' && event.name) {
-        output.tool = event.name;
-      } else if (event.type === 'error' && event.error) {
-        output.error = event.error;
-      }
-
-      console.log(JSON.stringify(output));
-    } else {
-      // Format output for text mode
-      switch (event.type) {
-        case 'tool_use':
-          console.log(`    [${agent.name}] 🔧 Using tool: ${event.name}`);
-          break;
-        case 'message':
-          console.log(`    [${agent.name}] 💬 ${event.content}`);
-          break;
-        case 'completion':
-          console.log(`    [${agent.name}] ✅ Task completed`);
-          break;
-        case 'error':
-          console.error(`    [${agent.name}] ❌ Error: ${event.error}`);
-          break;
-        default:
-          // Log other events in debug mode
-          if (this.options.logLevel === 'debug') {
-            console.log(`    [${agent.name}] ${event.type}: ${JSON.stringify(event)}`);
-          }
-      }
+   */ 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)}`);
+                    }
+            }
+        }
     }
-  }
-
-  /**
+    /**
    * 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, agent, workflow) {
-    // Use the claudePrompt from the task if available
-    if (task.claudePrompt) {
-      // Apply variable substitutions to the prompt
-      let basePrompt = task.claudePrompt;
-      const allVariables = { ...workflow.variables, ...task.input };
-
-      for (const [key, value] of Object.entries(allVariables)) {
-        const pattern = new RegExp(`\\$\\{${key}\\}`, 'g');
-        basePrompt = basePrompt.replace(pattern, value);
-      }
-
-      // Create comprehensive task prompt with MLE-STAR methodology
-      return `🎯 MLE-STAR AGENT TASK EXECUTION
+   */ 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
 
-You are the **${agent.name}** (${agent.type}) in a coordinated MLE-STAR automation workflow.
+You are the **${agent1.name}** (${agent1.type}) in a coordinated MLE-STAR automation workflow.
 
 📋 IMMEDIATE TASK:
 ${basePrompt}
 
 🤖 AGENT ROLE & SPECIALIZATION:
-${this.getAgentRoleDescription(agent.type)}
+${this.getAgentRoleDescription(agent1.type)}
 
 🎯 AGENT CAPABILITIES:
-${agent.config?.capabilities?.join(', ') || 'general automation'}
+${agent1.config?.capabilities?.join(', ') || 'general automation'}
 
 🔬 MLE-STAR METHODOLOGY FOCUS:
-${this.getMethodologyGuidance(agent.type)}
+${this.getMethodologyGuidance(agent1.type)}
 
 🔧 COORDINATION REQUIREMENTS:
 1. **HOOKS INTEGRATION** (CRITICAL):
@@ -475,20 +377,20 @@ ${this.getMethodologyGuidance(agent.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/${agent.id}/findings" "[your_findings]"\`
-   - Store results: \`npx claude-flow@alpha memory store "agent/${agent.id}/results" "[your_results]"\`
+   - 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]"\`
    - Check other agents: \`npx claude-flow@alpha memory search "agent/*"\`
 
 3. **SESSION COORDINATION**:
    - Session ID: ${this.sessionId}
    - Execution ID: ${this.executionId}
    - Task ID: ${task.id}
-   - Agent ID: ${agent.id}
+   - Agent ID: ${agent1.id}
 
 4. **WORKFLOW PIPELINE AWARENESS**:
-   - Your position: ${this.getAgentPositionInPipeline(agent.type)}
-   - Coordinate with: ${this.getCoordinationPartners(agent.type)}
-   - File naming: Use \`${agent.id}_[component].[ext]\` convention
+   - Your position: ${this.getAgentPositionInPipeline(agent1.type)}
+   - Coordinate with: ${this.getCoordinationPartners(agent1.type)}
+   - File naming: Use \`${agent1.id}_[component].[ext]\` convention
 
 5. **OUTPUT REQUIREMENTS**:
    - Use detailed progress reporting
@@ -512,33 +414,30 @@ ${this.getMethodologyGuidance(agent.type)}
 - Ready for next pipeline phase
 
 Begin execution now with the hooks pre-task command.`;
-    } else {
-      // Fallback to full agent prompt
-      return this.createAgentPrompt(agent);
+        } else {
+            // Fallback to full agent prompt
+            return this.createAgentPrompt(agent1);
+        }
     }
-  }
-
-  /**
+    /**
    * Create agent-specific Claude prompt
-   */
-  createAgentPrompt(agent) {
-    const { config } = agent;
-    const capabilities = config?.capabilities?.join(', ') || 'general automation';
-
-    return `You are the ${agent.name} in a coordinated MLE-STAR automation workflow.
+   */ 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.
 
-🎯 AGENT ROLE: ${agent.type.toUpperCase()}
+🎯 AGENT ROLE: ${agent1.type.toUpperCase()}
 📋 CAPABILITIES: ${capabilities}
-🆔 AGENT ID: ${agent.id}
+🆔 AGENT ID: ${agent1.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 '${agent.id}'" when complete
+   - Run "npx claude-flow@alpha hooks post-task --task-id '${agent1.id}'" when complete
 
 2. MEMORY: Store all findings and results:
-   - Use "npx claude-flow@alpha memory store 'agent/${agent.id}/[key]' '[value]'" for important data
+   - Use "npx claude-flow@alpha memory store 'agent/${agent1.id}/[key]' '[value]'" for important data
    - Check "npx claude-flow@alpha memory search 'agent/*'" for coordination with other agents
 
 3. SESSION: Maintain session coordination:
@@ -549,27 +448,24 @@ AGENT-SPECIFIC CONFIGURATION:
 ${JSON.stringify(config, null, 2)}
 
 MLE-STAR METHODOLOGY FOCUS:
-${this.getMethodologyGuidance(agent.type)}
+${this.getMethodologyGuidance(agent1.type)}
 
 WORKFLOW COORDINATION:
 - Work with other agents in the pipeline: Search → Foundation → Refinement → Ensemble → Validation
 - Share findings through memory system
-- Use proper file naming conventions: ${agent.id}_[component].[ext]
+- Use proper file naming conventions: ${agent1.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. 
 
@@ -579,15 +475,11 @@ 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(
-    (agent, index) => `
-${index + 1}. ${agent.name} (${agent.type})
-   🎯 Role: ${this.getAgentRoleDescription(agent.type)}
-   📋 Capabilities: ${agent.config?.capabilities?.join(', ') || 'general automation'}
-   🆔 ID: ${agent.id}`,
-  )
-  .join('')}
+${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('')}
 
 🔧 CRITICAL: USE CONCURRENT STREAMS FOR PARALLEL EXECUTION
 
@@ -638,28 +530,24 @@ 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
@@ -676,928 +564,796 @@ 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;
+   */ 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;
+            }
         }
-      });
-
-      // 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);
+        // Final summary
+        if (!concurrentDisplay) {
+            console.log(`\n📊 Final Workflow Summary:`);
+            this.displayTaskBoard(taskStatuses);
         } 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;
-          }
+            // Stop concurrent display
+            concurrentDisplay.stop();
+            console.log(); // Add some space after display
         }
-      }
-
-      // 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
+        };
     }
-
-    return {
-      success: failedTasks === 0,
-      totalTasks,
-      completedTasks,
-      failedTasks,
-      executionId: this.executionId,
-      duration: Date.now() - this.startTime,
-      results: Object.fromEntries(this.results),
-      errors: this.errors,
-    };
-  }
-
-  /**
+    /**
    * Display task board showing current status
-   */
-  displayTaskBoard(taskStatuses, highlightTasks = []) {
-    // In quiet mode, just show simple progress
-    if (this.options.logLevel === 'quiet') {
-      const totalTasks = taskStatuses.size;
-      const completedTasks = Array.from(taskStatuses.values()).filter(
-        (s) => s.status === 'completed',
-      ).length;
-      const activeTasks = Array.from(taskStatuses.values()).filter(
-        (s) => s.status === 'in-progress',
-      ).length;
-      console.log(`📊 Progress: ${completedTasks}/${totalTasks} completed, ${activeTasks} active`);
-      return;
-    }
-
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    const frameIndex = Math.floor(Date.now() / 100) % frames.length;
-    const spinner = frames[frameIndex];
-
-    console.log('\n╔═══════════════════════════════════════════════════════════════╗');
-    console.log('║                    🤖 CONCURRENT TASK STATUS                   ║');
-    console.log('╠═══════════════════════════════════════════════════════════════╣');
-
-    // Group by status
-    const statusGroups = {
-      'in-progress': [],
-      completed: [],
-      failed: [],
-      pending: [],
-    };
-
-    taskStatuses.forEach((status, taskId) => {
-      statusGroups[status.status].push({ taskId, ...status });
-    });
-
-    // Show in-progress tasks with animation
-    if (statusGroups['in-progress'].length > 0) {
-      console.log(
-        `║ ${spinner} RUNNING (${statusGroups['in-progress'].length} agents):                                      ║`,
-      );
-      statusGroups['in-progress'].forEach((task) => {
-        const duration = task.startTime ? this.formatDuration(Date.now() - task.startTime) : '';
-        const progress = this.getProgressBar(Date.now() - task.startTime, 60000); // 1 min expected
-        const agentIcon = this.getAgentIcon(task.agent);
-        console.log(
-          `║   ${agentIcon} ${task.name.padEnd(25)} ${progress} ${duration.padStart(8)} ║`,
-        );
-      });
-    }
-
-    // Show completed tasks
-    if (statusGroups['completed'].length > 0) {
-      console.log(
-        `║ ✅ COMPLETED (${statusGroups['completed'].length}):                                           ║`,
-      );
-      statusGroups['completed'].forEach((task) => {
-        const duration =
-          task.endTime && task.startTime ? this.formatDuration(task.endTime - task.startTime) : '';
-        console.log(`║   ✓ ${task.name.padEnd(35)} ${duration.padStart(10)} ║`);
-      });
-    }
-
-    // Show failed tasks
-    if (statusGroups['failed'].length > 0) {
-      console.log(
-        `║ ❌ FAILED (${statusGroups['failed'].length}):                                              ║`,
-      );
-      statusGroups['failed'].forEach((task) => {
-        const errorMsg = (task.summary || '').substring(0, 25);
-        console.log(`║   ✗ ${task.name.padEnd(25)} ${errorMsg.padEnd(20)} ║`);
-      });
-    }
-
-    // Show pending tasks count
-    if (statusGroups['pending'].length > 0) {
-      console.log(
-        `║ ⏳ QUEUED: ${statusGroups['pending'].length} tasks waiting                                 ║`,
-      );
-    }
-
-    // Summary stats
-    const total = taskStatuses.size;
-    const completed = statusGroups['completed'].length;
-    const failed = statusGroups['failed'].length;
-    const progress = total > 0 ? Math.floor(((completed + failed) / total) * 100) : 0;
-
-    console.log('╠═══════════════════════════════════════════════════════════════╣');
-    console.log(
-      `║ 📊 Progress: ${progress}% (${completed}/${total}) │ ⚡ Active: ${statusGroups['in-progress'].length} │ ❌ Failed: ${failed}  ║`,
-    );
-    console.log('╚═══════════════════════════════════════════════════════════════╝');
-  }
-
-  /**
-   * Get progress bar visualization
-   */
-  getProgressBar(elapsed, expected) {
-    const progress = Math.min(elapsed / expected, 1);
-    const filled = Math.floor(progress * 10);
-    const empty = 10 - filled;
-    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
-  }
-
-  /**
-   * Get agent icon based on type
-   */
-  getAgentIcon(agentId) {
-    const icons = {
-      search: '🔍',
-      foundation: '🏗️',
-      refinement: '🔧',
-      ensemble: '🎯',
-      validation: '✅',
-      coordinator: '🎮',
-      researcher: '🔬',
-      coder: '💻',
-      optimizer: '⚡',
-      architect: '🏛️',
-      tester: '🧪',
-    };
-
-    // Extract agent type from ID
-    const type = agentId?.split('_')[0] || 'default';
-    return icons[type] || '🤖';
-  }
-
-  /**
-   * Execute a single task
-   */
-  async executeTask(task, workflow) {
-    const startTime = Date.now();
-
-    try {
-      // Store task execution in memory if hooks enabled
-      if (this.hooksEnabled) {
-        await this.executeHook('notify', {
-          message: `Starting task: ${task.name || task.id}`,
-          sessionId: this.sessionId,
-        });
-      }
-
-      if (this.options.nonInteractive && this.options.outputFormat === 'stream-json') {
-        console.log(`\n● ${task.name || task.id} - Starting Execution`);
-        console.log(`  ⎿  ${task.description}`);
-        console.log(`  ⎿  Agent: ${task.assignTo}`);
-      } else {
-        console.log(`    🔄 Executing: ${task.description}`);
-      }
-
-      // For demonstration/testing mode (when Claude integration is disabled)
-      // we simulate successful task completion
-      if (!this.options.enableClaude) {
-        // Simulate variable execution time
-        const executionTime = Math.min(
-          1000 + Math.random() * 3000, // 1-4 seconds simulation
-          task.timeout || 30000,
-        );
-
-        await new Promise((resolve) => setTimeout(resolve, executionTime));
-
-        // Simulate successful completion for demo/testing
-        const result = {
-          success: true,
-          taskId: task.id,
-          duration: Date.now() - startTime,
-          output: {
-            status: 'completed',
-            agent: task.assignTo,
-            executionTime: Date.now() - startTime,
-            metadata: {
-              timestamp: new Date().toISOString(),
-              executionId: this.executionId,
-              mode: 'simulation',
-            },
-          },
-        };
-
-        // Store result in memory
-        if (this.hooksEnabled) {
-          await this.storeTaskResult(task.id, result.output);
+   */ 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;
         }
-
-        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}`));
-              }
+        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
             });
-
-            masterCoordinator.process.on('error', (err) => {
-              reject(err);
+        });
+        // 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)} ║`);
             });
-          });
-
-          // For interactive mode, we use a longer timeout since user interaction is involved
-          const timeout = Math.max(this.options.timeout, 1800000); // 30 minutes minimum for interactive
-          const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error('Interactive session timeout')), timeout);
-          });
-
-          try {
-            await Promise.race([completionPromise, timeoutPromise]);
-
-            const result = {
-              success: true,
-              taskId: task.id,
-              duration: Date.now() - startTime,
-              output: {
-                status: 'completed',
-                agent: 'master-coordinator',
-                executionTime: Date.now() - startTime,
-                metadata: {
-                  timestamp: new Date().toISOString(),
-                  executionId: this.executionId,
-                  mode: 'interactive-coordination',
-                },
-              },
-            };
-
-            // Store result in memory
-            if (this.hooksEnabled) {
-              await this.storeTaskResult(task.id, result.output);
-            }
-
-            return result;
-          } catch (error) {
-            throw new Error(`Task execution failed: ${error.message}`);
-          }
         }
-
-        // Non-interactive mode or no master coordinator: use individual Claude instances
-        const claudeInstance = this.claudeInstances.get(task.assignTo);
-        if (!claudeInstance) {
-          // If no pre-spawned instance, create one for this task
-          const agent = workflow.agents.find((a) => a.id === task.assignTo);
-          if (!agent) {
-            throw new Error(`No agent definition found for: ${task.assignTo}`);
-          }
-
-          // Create task-specific prompt
-          const taskPrompt = this.createTaskPrompt(task, agent, workflow);
-
-          // Check if we should chain from a previous task
-          let chainOptions = {};
-          if (
-            this.enableChaining &&
-            this.options.outputFormat === 'stream-json' &&
-            task.depends?.length > 0
-          ) {
-            // Get the output stream from the last dependency
-            const lastDependency = task.depends[task.depends.length - 1];
-            const dependencyStream = this.taskOutputStreams.get(lastDependency);
-            if (dependencyStream) {
-              console.log(`    🔗 Enabling stream chaining from ${lastDependency} to ${task.id}`);
-              chainOptions.inputStream = dependencyStream;
-            }
-          }
-
-          // Spawn Claude instance for this specific task
-          const taskClaudeProcess = await this.spawnClaudeInstance(agent, taskPrompt, chainOptions);
-
-          // Store the output stream for potential chaining
-          if (
-            this.enableChaining &&
-            this.options.outputFormat === 'stream-json' &&
-            taskClaudeProcess.stdout
-          ) {
-            this.taskOutputStreams.set(task.id, taskClaudeProcess.stdout);
-          }
-
-          // Store the instance
-          this.claudeInstances.set(agent.id, {
-            process: taskClaudeProcess,
-            agent: agent,
-            status: 'active',
-            startTime: Date.now(),
-            taskId: task.id,
-          });
-
-          // Wait for task completion or timeout
-          // Use longer timeout for ML tasks
-          const baseTimeout = this.options.timeout || 60000;
-          const isMLTask =
-            task.type?.toLowerCase().includes('ml') ||
-            task.type?.toLowerCase().includes('model') ||
-            task.type?.toLowerCase().includes('search') ||
-            task.type?.toLowerCase().includes('analysis') ||
-            this.options.workflowType === 'ml';
-          const timeout = task.timeout || (isMLTask ? Math.max(baseTimeout, 300000) : baseTimeout); // Min 5 minutes for ML tasks
-
-          if (this.options.logLevel === 'debug' || this.options.verbose) {
-            console.log(
-              `    ⏱️  Timeout: ${this.formatDuration(timeout)} (Base: ${this.formatDuration(baseTimeout)}, ML Task: ${isMLTask})`,
-            );
-          }
-
-          const completionPromise = new Promise((resolve, reject) => {
-            taskClaudeProcess.on('exit', (code) => {
-              if (code === 0) {
-                resolve({ success: true, code });
-              } else {
-                reject(new Error(`Process exited with code ${code}`));
-              }
+        // 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)} ║`);
             });
-
-            taskClaudeProcess.on('error', (err) => {
-              reject(err);
+        }
+        // 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)} ║`);
             });
-          });
-
-          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
+        }
+        // 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.storeTaskResult(task.id, result.output);
+                await this.executeHook('notify', {
+                    message: `Starting task: ${task.name || task.id}`,
+                    sessionId: this.sessionId
+                });
             }
-
-            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;
+            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 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);
+            // 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;
-          }
+        } catch (error) {
+            return {
+                success: false,
+                taskId: task.id,
+                duration: Date.now() - startTime,
+                error: 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));
+   */ 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;
     }
-
-    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);
+   */ 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);
     }
-
-    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');
+   */ 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);
             }
-          }, 5000);
         }
-
-        console.log(`  ✅ Cleaned up ${instance.agent.name}`);
-      } catch (error) {
-        console.error(`  ❌ Error cleaning up ${instance.agent.name}:`, error.message);
-      }
+        this.claudeInstances.clear();
     }
-
-    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`;
+   */ 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');
     }
-  }
 }
-
 /**
  * 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');
+ */ 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}`);
     }
-  } 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');
 }