claude-flow-novice 1.5.6 → 1.5.8

package/.claude-flow-novice/dist/src/mcp/ruv-swarm-wrapper.js

@@ -0,0 +1,254 @@
+/**
+ * Wrapper for ruv-swarm MCP server to handle logger issues
+ * This wrapper ensures compatibility and handles known issues in ruv-swarm
+ */
+
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+
+export class RuvSwarmWrapper {
+  constructor(options = {}) {
+    this.options = {
+      silent: options.silent || false,
+      autoRestart: options.autoRestart !== false,
+      maxRestarts: options.maxRestarts || 3,
+      restartDelay: options.restartDelay || 1000,
+      ...options,
+    };
+
+    this.process = null;
+    this.restartCount = 0;
+    this.isShuttingDown = false;
+  }
+
+  async start() {
+    if (this.process) {
+      throw new Error('RuvSwarm MCP server is already running');
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        // Spawn ruv-swarm MCP server
+        this.process = spawn('npx', ['ruv-swarm', 'mcp', 'start'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: {
+            ...process.env,
+            // Ensure stdio mode for MCP
+            MCP_MODE: 'stdio',
+            // Set log level to reduce noise
+            LOG_LEVEL: 'WARN',
+          },
+        });
+
+        let initialized = false;
+        let initTimeout;
+
+        // Handle stdout (JSON-RPC messages)
+        const rlOut = createInterface({
+          input: this.process.stdout,
+          crlfDelay: Infinity,
+        });
+
+        rlOut.on('line', (line) => {
+          try {
+            const message = JSON.parse(line);
+
+            // Check for initialization
+            if (message.method === 'server.initialized' && !initialized) {
+              initialized = true;
+              clearTimeout(initTimeout);
+              resolve({
+                process: this.process,
+                stdout: this.process.stdout,
+                stdin: this.process.stdin,
+              });
+            }
+
+            // Forward JSON-RPC messages
+            process.stdout.write(line + '\n');
+          } catch (err) {
+            // Not JSON, ignore
+          }
+        });
+
+        // Handle stderr (logs and errors)
+        const rlErr = createInterface({
+          input: this.process.stderr,
+          crlfDelay: Infinity,
+        });
+
+        rlErr.on('line', (line) => {
+          // Parse structured error messages if available
+          try {
+            const errorData = JSON.parse(line);
+            if (errorData.error && errorData.error.code) {
+              // Handle specific error codes
+              switch (errorData.error.code) {
+                case 'LOGGER_METHOD_MISSING':
+                case 'ERR_LOGGER_MEMORY_USAGE':
+                  // Known issue with logger.logMemoryUsage in ruv-swarm
+                  if (!this.options.silent) {
+                    console.error(
+                      '⚠️  Known ruv-swarm logger issue detected (continuing normally)',
+                    );
+                  }
+                  return;
+                case 'ERR_INITIALIZATION':
+                  console.error('❌ RuvSwarm initialization error:', errorData.error.message);
+                  return;
+                default:
+                  // Unknown error code, log it
+                  if (!this.options.silent) {
+                    console.error(
+                      `RuvSwarm error [${errorData.error.code}]:`,
+                      errorData.error.message,
+                    );
+                  }
+              }
+              return;
+            }
+          } catch (e) {
+            // Not JSON, check for known text patterns as fallback
+            const knownErrorPatterns = [
+              {
+                pattern: /logger\.logMemoryUsage is not a function/,
+                code: 'LOGGER_METHOD_MISSING',
+                message: 'Known ruv-swarm logger issue detected (continuing normally)',
+              },
+              {
+                pattern: /Cannot find module/,
+                code: 'MODULE_NOT_FOUND',
+                message: 'Module not found error',
+              },
+              {
+                pattern: /ECONNREFUSED/,
+                code: 'CONNECTION_REFUSED',
+                message: 'Connection refused error',
+              },
+            ];
+
+            for (const errorPattern of knownErrorPatterns) {
+              if (errorPattern.pattern.test(line)) {
+                if (!this.options.silent || errorPattern.code !== 'LOGGER_METHOD_MISSING') {
+                  console.error(`⚠️  ${errorPattern.message}`);
+                }
+                return;
+              }
+            }
+          }
+
+          // Filter out initialization messages if silent
+          if (this.options.silent) {
+            if (line.includes('✅') || line.includes('🧠') || line.includes('📊')) {
+              return;
+            }
+          }
+
+          // Forward other stderr output
+          if (!this.options.silent) {
+            process.stderr.write(line + '\n');
+          }
+        });
+
+        // Handle process errors
+        this.process.on('error', (error) => {
+          if (!initialized) {
+            clearTimeout(initTimeout);
+            reject(new Error(`Failed to start ruv-swarm: ${error.message}`));
+          } else {
+            console.error('RuvSwarm process error:', error);
+            this.handleProcessExit(error.code || 1);
+          }
+        });
+
+        // Handle process exit
+        this.process.on('exit', (code, signal) => {
+          if (!initialized) {
+            clearTimeout(initTimeout);
+            reject(
+              new Error(`RuvSwarm exited before initialization: code ${code}, signal ${signal}`),
+            );
+          } else {
+            this.handleProcessExit(code || 0);
+          }
+        });
+
+        // Set initialization timeout
+        initTimeout = setTimeout(() => {
+          if (!initialized) {
+            this.stop();
+            reject(new Error('RuvSwarm initialization timeout'));
+          }
+        }, 30000); // 30 second timeout
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  handleProcessExit(code) {
+    this.process = null;
+
+    if (this.isShuttingDown) {
+      return;
+    }
+
+    console.error(`RuvSwarm MCP server exited with code ${code}`);
+
+    // Auto-restart if enabled and under limit
+    if (this.options.autoRestart && this.restartCount < this.options.maxRestarts) {
+      this.restartCount++;
+      console.log(
+        `Attempting to restart RuvSwarm (attempt ${this.restartCount}/${this.options.maxRestarts})...`,
+      );
+
+      setTimeout(() => {
+        this.start().catch((err) => {
+          console.error('Failed to restart RuvSwarm:', err);
+        });
+      }, this.options.restartDelay);
+    }
+  }
+
+  async stop() {
+    this.isShuttingDown = true;
+
+    if (!this.process) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      const killTimeout = setTimeout(() => {
+        console.warn('RuvSwarm did not exit gracefully, forcing kill...');
+        this.process.kill('SIGKILL');
+      }, 5000);
+
+      this.process.on('exit', () => {
+        clearTimeout(killTimeout);
+        this.process = null;
+        resolve();
+      });
+
+      // Send graceful shutdown signal
+      this.process.kill('SIGTERM');
+    });
+  }
+
+  isRunning() {
+    return this.process !== null && !this.process.killed;
+  }
+}
+
+// Export a function to start ruv-swarm with error handling
+export async function startRuvSwarmMCP(options = {}) {
+  const wrapper = new RuvSwarmWrapper(options);
+
+  try {
+    const result = await wrapper.start();
+    console.log('✅ RuvSwarm MCP server started successfully');
+    return { wrapper, ...result };
+  } catch (error) {
+    console.error('❌ Failed to start RuvSwarm MCP server:', error.message);
+    throw error;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "description": "Standalone Claude Flow for beginners - AI agent orchestration made easy with enhanced TDD testing pipeline. Enhanced init command creates complete agent system, MCP configuration with 30 essential tools, and automated hooks with single-file testing, real-time coverage analysis, and advanced validation. Fully standalone with zero external dependencies, complete project setup in one command.",
   "mcpName": "io.github.ruvnet/claude-flow",
   "main": ".claude-flow-novice/dist/index.js",
@@ -39,7 +39,7 @@
     "optimize:validate:hardware": "node scripts/optimization/config-validator.js validate hardware",
     "optimize:validate:monitoring": "node scripts/optimization/config-validator.js validate monitoring",
     "build": "scripts/build/unified-builder.sh safe",
-    "build:swc": "swc src -d .claude-flow-novice/dist --only='**/*.ts' --config-file .swcrc && cp -r src/slash-commands .claude-flow-novice/dist/src/ && cp -r src/cli/simple-commands/hooks .claude-flow-novice/dist/src/cli/simple-commands/ && cp -r src/cli/simple-commands/init/templates .claude-flow-novice/dist/src/cli/simple-commands/init/ && cp src/cli/simple-commands/init/index.js .claude-flow-novice/dist/src/cli/simple-commands/init/ && cp src/cli/simple-commands/init.js .claude-flow-novice/dist/src/cli/simple-commands/ && cp -r .claude/agents .claude-flow-novice/.claude/",
+    "build:swc": "swc src -d .claude-flow-novice/dist --only='**/*.ts' --config-file .swcrc && cp -r src/slash-commands .claude-flow-novice/dist/src/ && cp -r src/cli/simple-commands/hooks .claude-flow-novice/dist/src/cli/simple-commands/ && cp -r src/cli/simple-commands/init/templates .claude-flow-novice/dist/src/cli/simple-commands/init/ && cp src/cli/simple-commands/init/index.js .claude-flow-novice/dist/src/cli/simple-commands/init/ && cp src/cli/simple-commands/init.js .claude-flow-novice/dist/src/cli/simple-commands/ && cp src/cli/simple-commands/mcp.js .claude-flow-novice/dist/src/cli/simple-commands/ && cp src/mcp/*.js .claude-flow-novice/dist/src/mcp/ && cp -r .claude/agents .claude-flow-novice/.claude/",
     "build:types": "tsc --project config/typescript/tsconfig.json --emitDeclarationOnly --outDir .claude-flow-novice/dist --skipLibCheck",
     "build:watch": "swc src -d .claude-flow-novice/dist --watch --config-file .swcrc && cp -r src/slash-commands .claude-flow-novice/dist/src/ && cp -r src/cli/simple-commands/hooks .claude-flow-novice/dist/src/cli/simple-commands/ && cp -r src/cli/simple-commands/init/templates .claude-flow-novice/dist/src/cli/simple-commands/init/ && npm run copy:agents",
     "build:legacy": "scripts/build/unified-builder.sh migration",

package/src/cli/simple-commands/init/index.js

@@ -64,14 +64,8 @@ import {
   createHelperScript,
   COMMAND_STRUCTURE,
 } from './templates/enhanced-templates.js';
-import { createOptimizedSparcClaudeMd } from './templates/claude-md.js';
 import { getIsolatedNpxEnv } from '../../../utils/npx-isolated-cache.js';
 import { updateGitignore, needsGitignoreUpdate } from './gitignore-updater.js';
-import {
-  createFullClaudeMd,
-  createSparcClaudeMd,
-  createMinimalClaudeMd,
-} from './templates/claude-md.js';
 import {
   createVerificationClaudeMd,
   createVerificationSettingsJson,
@@ -271,13 +265,6 @@ export async function initCommand(subArgs, flags) {
     return handleBatchInit(subArgs, flags);
   }
 
-  // For novice package, always use enhanced initialization with agent system
-  const useEnhanced = true; // Always enhanced for novice users
-
-  if (useEnhanced) {
-    return enhancedInitCommand(subArgs, flags);
-  }
-
   // Parse init options
   const initForce = subArgs.includes('--force') || subArgs.includes('-f') || flags.force;
   const initMinimal = subArgs.includes('--minimal') || subArgs.includes('-m') || flags.minimal;
@@ -1047,11 +1034,8 @@ async function performInitializationWithCheckpoints(
 // Helper functions for atomic initialization
 async function createInitialFiles(options, workingDir, dryRun = false) {
   if (!dryRun) {
-    const claudeMd = options.sparc
-      ? createSparcClaudeMd()
-      : options.minimal
-        ? createMinimalClaudeMd()
-        : createFullClaudeMd();
+    // Use template file instead of generation
+    const claudeMd = await readClaudeMdTemplate();
     await fs.writeFile(`${workingDir}/CLAUDE.md`, claudeMd, 'utf8');
 
     const memoryBankMd = options.minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();

package/src/cli/simple-commands/init/template-copier.js

@@ -498,98 +498,35 @@ async function createMemoryReadmeFiles(targetDir, options, results) {
 }
 
 /**
- * Get template content as fallback (for backwards compatibility)
+ * Get template content from template file only (NO GENERATION)
  */
 async function getTemplateContent(templatePath) {
   const filename = templatePath.split('/').pop();
 
-  // Map template files to their generator functions
-  const templateGenerators = {
-    'CLAUDE.md': async () => {
-      const { createFullClaudeMd } = await import('./templates/claude-md.js');
-      return createFullClaudeMd();
-    },
-    'CLAUDE.md.sparc': async () => {
-      const { createSparcClaudeMd } = await import('./templates/claude-md.js');
-      return createSparcClaudeMd();
-    },
-    'CLAUDE.md.minimal': async () => {
-      const { createMinimalClaudeMd } = await import('./templates/claude-md.js');
-      return createMinimalClaudeMd();
-    },
-    'CLAUDE.md.optimized': async () => {
-      const { createOptimizedSparcClaudeMd } = await import('./templates/claude-md.js');
-      return createOptimizedSparcClaudeMd();
-    },
-    'CLAUDE.md.enhanced': async () => {
-      const { createEnhancedClaudeMd } = await import('./templates/enhanced-templates.js');
-      return createEnhancedClaudeMd();
-    },
-    'CLAUDE.md.verification': async () => {
-      const { createVerificationClaudeMd } = await import('./templates/verification-claude-md.js');
-      return createVerificationClaudeMd();
-    },
-    'memory-bank.md': async () => {
-      const { createFullMemoryBankMd } = await import('./templates/memory-bank-md.js');
-      return createFullMemoryBankMd();
-    },
-    'memory-bank.md.minimal': async () => {
-      const { createMinimalMemoryBankMd } = await import('./templates/memory-bank-md.js');
-      return createMinimalMemoryBankMd();
-    },
-    'memory-bank.md.optimized': async () => {
-      const { createOptimizedMemoryBankMd } = await import('./templates/memory-bank-md.js');
-      return createOptimizedMemoryBankMd();
-    },
-    'coordination.md': async () => {
-      const { createFullCoordinationMd } = await import('./templates/coordination-md.js');
-      return createFullCoordinationMd();
-    },
-    'coordination.md.minimal': async () => {
-      const { createMinimalCoordinationMd } = await import('./templates/coordination-md.js');
-      return createMinimalCoordinationMd();
-    },
-    'coordination.md.optimized': async () => {
-      const { createOptimizedCoordinationMd } = await import('./templates/coordination-md.js');
-      return createOptimizedCoordinationMd();
-    },
-    'settings.json': async () => {
-      return await fs.readFile(join(__dirname, 'templates', 'settings.json'), 'utf8');
-    },
-    'settings.json.enhanced': async () => {
-      const { createEnhancedSettingsJson } = await import('./templates/enhanced-templates.js');
-      return createEnhancedSettingsJson();
-    },
-    'settings.json.verification': async () => {
-      const { createVerificationSettingsJson } = await import(
-        './templates/verification-claude-md.js'
-      );
-      return createVerificationSettingsJson();
-    },
-    'claude-flow-universal': async () => {
-      return await fs.readFile(join(__dirname, 'templates', 'claude-flow-universal'), 'utf8');
-    },
-    'claude-flow.bat': async () => {
-      return await fs.readFile(join(__dirname, 'templates', 'claude-flow.bat'), 'utf8');
-    },
-    'claude-flow.ps1': async () => {
-      return await fs.readFile(join(__dirname, 'templates', 'claude-flow.ps1'), 'utf8');
-    },
-  };
+  // Try to read from the actual template file ONLY
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
 
-  const generator =
-    templateGenerators[filename] ||
-    templateGenerators[filename.replace(/\.(sparc|minimal|optimized|enhanced)$/, '')];
+  // Try multiple possible template locations
+  const templatePaths = [
+    join(__dirname, 'templates', filename),  // Source location: src/cli/simple-commands/init/templates/
+    join(__dirname, filename),                // Dist location: dist/src/cli/simple-commands/init/ (files copied directly)
+  ];
 
-  if (generator) {
+  for (const actualTemplatePath of templatePaths) {
     try {
-      return await generator();
+      const content = await fs.readFile(actualTemplatePath, 'utf8');
+      console.log(`  ✓ Using template from ${actualTemplatePath}`);
+      return content;
     } catch (err) {
-      console.log(`  ⚠️  Failed to generate template content for ${filename}: ${err.message}`);
-      return null;
+      // Try next path
+      continue;
     }
   }
 
+  // NO FALLBACK TO GENERATION - Template file must exist
+  console.log(`  ⚠️  Template file not found for ${filename}`);
+  console.log(`  💡 Template files must be present in src/cli/simple-commands/init/templates/`);
   return null;
 }
 

package/examples/sdk-swarm-demo.js

@@ -1,194 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SDK Swarm Integration Demo
- *
- * Demonstrates how to use the SDK Swarm Orchestrator for parallel agent execution
- * with self-validation and Byzantine consensus.
- *
- * Usage:
- *   node examples/sdk-swarm-demo.js
- */
-
-import { SDKSwarmOrchestrator } from '../src/sdk/swarm-integration.js';
-
-async function main() {
-  console.log('🚀 SDK Swarm Integration Demo\n');
-
-  // Step 1: Create and initialize orchestrator
-  console.log('Step 1: Creating SDK Swarm Orchestrator...');
-  const orchestrator = new SDKSwarmOrchestrator({
-    swarmId: 'demo-swarm',
-    maxAgents: 10,
-    maxConcurrent: 3,
-    consensusProtocol: 'pbft',
-    consensusQuorumSize: 2,
-    consensusTimeout: 5000,
-    parallelExecution: true,
-    filterFailedValidations: true,
-    minimumValidAgents: 1,
-    enableLearning: true,
-    enableMetrics: true
-  });
-
-  await orchestrator.initialize();
-  console.log('✅ Orchestrator initialized\n');
-
-  // Step 2: Define task with agent configuration
-  console.log('Step 2: Defining task with multiple agents...');
-  const task = {
-    description: 'Implement user authentication feature',
-    operation: 'implement',
-    file: 'src/auth/user-auth.js',
-    content: 'User authentication logic',
-    agents: [
-      {
-        agentId: 'coder-1',
-        agentType: 'coder',
-        confidenceThreshold: 0.75,
-        maxRetries: 3,
-        minimumCoverage: 80
-      },
-      {
-        agentId: 'coder-2',
-        agentType: 'coder',
-        confidenceThreshold: 0.80,
-        maxRetries: 3,
-        minimumCoverage: 85
-      },
-      {
-        agentId: 'tester-1',
-        agentType: 'tester',
-        confidenceThreshold: 0.80,
-        maxRetries: 3,
-        minimumCoverage: 90
-      },
-      {
-        agentId: 'reviewer-1',
-        agentType: 'reviewer',
-        confidenceThreshold: 0.75,
-        maxRetries: 2,
-        minimumCoverage: 75
-      }
-    ]
-  };
-  console.log('✅ Task defined with 4 agents\n');
-
-  // Step 3: Execute with consensus
-  console.log('Step 3: Executing task with parallel agents and consensus...');
-  console.log('─'.repeat(80));
-
-  const result = await orchestrator.executeWithConsensus(task);
-
-  console.log('─'.repeat(80));
-  console.log('\n✅ Execution completed!\n');
-
-  // Step 4: Display results
-  console.log('📊 Execution Results:');
-  console.log('═'.repeat(80));
-  console.log(`Status:           ${result.status}`);
-  console.log(`Reason:           ${result.reason}`);
-  console.log(`Execution ID:     ${result.executionId}`);
-  console.log(`Timestamp:        ${new Date(result.timestamp).toISOString()}`);
-
-  console.log('\n📈 Statistics:');
-  console.log('─'.repeat(80));
-  console.log(`Agents Spawned:        ${result.stats.agentsSpawned}`);
-  console.log(`Validations Passed:    ${result.stats.validationPassed}`);
-  console.log(`Validations Failed:    ${result.stats.validationFailed}`);
-  console.log(`Validation Rate:       ${result.stats.validationRate}`);
-  console.log(`Avg Confidence:        ${result.stats.avgConfidence}`);
-  console.log(`Avg Attempts:          ${result.stats.avgAttempts}`);
-  console.log(`Total Duration:        ${result.stats.totalDuration}`);
-  console.log(`Avg Agent Duration:    ${result.stats.avgAgentDuration}`);
-
-  if (result.stats.consensus) {
-    console.log('\n🤝 Consensus Results:');
-    console.log('─'.repeat(80));
-    console.log(`Decision:              ${result.stats.consensus.decision}`);
-    console.log(`Consensus Time:        ${result.stats.consensus.consensusTime}`);
-    console.log(`Participation Rate:    ${result.stats.consensus.participationRate}`);
-    console.log(`Total Votes:           ${result.stats.consensus.votes.total}`);
-    console.log(`Approved:              ${result.stats.consensus.votes.approved}`);
-    console.log(`Rejected:              ${result.stats.consensus.votes.rejected}`);
-  }
-
-  console.log('\n🎯 Quality Metrics:');
-  console.log('─'.repeat(80));
-  console.log(`Total Coverage:        ${result.stats.metrics.totalCoverage}%`);
-  console.log(`Tests Passed:          ${result.stats.metrics.totalTestsPassed}`);
-  console.log(`Tests Failed:          ${result.stats.metrics.totalTestsFailed}`);
-
-  // Step 5: Display individual agent results
-  console.log('\n🤖 Individual Agent Results:');
-  console.log('═'.repeat(80));
-
-  result.results.forEach((agentResult, index) => {
-    console.log(`\nAgent ${index + 1}: ${agentResult.agentId} (${agentResult.agentType})`);
-    console.log('─'.repeat(80));
-    console.log(`Status:        ${agentResult.isValid() ? '✅ VALID' : '❌ INVALID'}`);
-    console.log(`Confidence:    ${(agentResult.getConfidence() * 100).toFixed(1)}%`);
-    console.log(`Attempts:      ${agentResult.attempts}`);
-    console.log(`Duration:      ${agentResult.duration.toFixed(2)}ms`);
-
-    if (agentResult.validation?.metrics) {
-      console.log(`Coverage:      ${agentResult.validation.metrics.coverage}%`);
-      console.log(`Tests Passed:  ${agentResult.validation.metrics.testsPassed}`);
-      console.log(`Tests Failed:  ${agentResult.validation.metrics.testsFailed}`);
-    }
-
-    if (agentResult.error) {
-      console.log(`Error:         ${agentResult.error}`);
-    }
-  });
-
-  // Step 6: Get orchestrator metrics
-  console.log('\n\n📊 Orchestrator Metrics:');
-  console.log('═'.repeat(80));
-
-  const metrics = orchestrator.getMetrics();
-
-  console.log('\nSwarm:');
-  console.log(`  Swarm ID:            ${metrics.swarm.swarmId}`);
-  console.log(`  Agents Registered:   ${metrics.swarm.agentsRegistered}`);
-  console.log(`  Active Executions:   ${metrics.swarm.activeExecutions}`);
-  console.log(`  Parallel Execution:  ${metrics.swarm.parallelExecution}`);
-
-  console.log('\nTasks:');
-  console.log(`  Total:               ${metrics.tasks.total}`);
-  console.log(`  Successful:          ${metrics.tasks.successful}`);
-  console.log(`  Failed:              ${metrics.tasks.failed}`);
-  console.log(`  Success Rate:        ${metrics.tasks.successRate}`);
-
-  console.log('\nValidation:');
-  console.log(`  Passed:              ${metrics.validation.passed}`);
-  console.log(`  Failed:              ${metrics.validation.failed}`);
-  console.log(`  Pass Rate:           ${metrics.validation.passRate}`);
-  console.log(`  Avg Duration:        ${metrics.validation.avgDuration}`);
-
-  console.log('\nConsensus:');
-  console.log(`  Reached:             ${metrics.consensus.reached}`);
-  console.log(`  Failed:              ${metrics.consensus.failed}`);
-  console.log(`  Success Rate:        ${metrics.consensus.successRate}`);
-  console.log(`  Avg Duration:        ${metrics.consensus.avgDuration}`);
-  console.log(`  Protocol:            ${metrics.consensus.protocol}`);
-  console.log(`  Quorum Size:         ${metrics.consensus.quorumSize}`);
-
-  console.log('\nPerformance:');
-  console.log(`  Avg Task Duration:   ${metrics.performance.avgTaskDuration}`);
-  console.log(`  Tasks Completed:     ${metrics.performance.tasksCompleted}`);
-  console.log(`  Agents Spawned:      ${metrics.performance.agentsSpawned}`);
-
-  // Step 7: Cleanup
-  console.log('\n\n🧹 Cleaning up...');
-  await orchestrator.shutdown();
-  console.log('✅ Orchestrator shut down cleanly');
-
-  console.log('\n🎉 Demo completed successfully!\n');
-}
-
-// Run demo
-main().catch(error => {
-  console.error('\n❌ Demo failed:', error);
-  process.exit(1);
-});