claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/cli/init/batch-tools.js

@@ -1,387 +0,0 @@
-// init/batch-tools.ts - Batch tools coordination guides
-export async function createBatchToolsGuide() {
-    const fs = await import('fs/promises');
-    const path = await import('path');
-    const batchToolsDir = '.claude/commands/swarm';
-    const batchToolsGuide = `# Batch Tools Coordination Guide
-
-## Overview
-This guide explains how to use Claude Code's batch tools effectively for swarm orchestration and parallel task execution.
-
-## Core Batch Tools
-
-### TodoWrite/TodoRead - Task Coordination Engine
-The foundation of all swarm operations - manages task distribution, progress tracking, and coordination.
-
-#### TodoWrite Usage
-\`\`\`javascript
-// Create comprehensive task breakdown
-TodoWrite([
-  {
-    id: "research_phase",
-    content: "Research cloud architecture patterns",
-    status: "pending",
-    priority: "high",
-    dependencies: [],
-    estimatedTime: "30min",
-    assignedAgent: "research_specialist"
-  },
-  {
-    id: "analysis_phase", 
-    content: "Analyze performance requirements",
-    status: "pending",
-    priority: "medium",
-    dependencies: ["research_phase"],
-    estimatedTime: "45min",
-    assignedAgent: "performance_analyst"
-  },
-  {
-    id: "implementation_phase",
-    content: "Implement optimized solution",
-    status: "pending", 
-    priority: "high",
-    dependencies: ["research_phase", "analysis_phase"],
-    estimatedTime: "90min",
-    assignedAgent: "implementation_specialist"
-  }
-]);
-\`\`\`
-
-#### TodoRead Monitoring
-\`\`\`javascript
-// Regular progress checks
-const progress = TodoRead();
-console.log("Current progress:", progress);
-
-// Check specific task status
-const researchStatus = TodoRead().find(task => task.id === "research_phase");
-if (researchStatus.status === "completed") {
-  // Trigger dependent tasks
-  updateTaskStatus("analysis_phase", "in_progress");
-}
-\`\`\`
-
-### Task Tool - Parallel Agent Orchestration
-Launches multiple specialized agents simultaneously for maximum efficiency.
-
-#### Basic Agent Launching
-\`\`\`javascript
-// Launch specialized agents for different domains
-Task("Architecture Research", 
-     "Research microservices architecture patterns and best practices for scalable systems");
-
-Task("Performance Analysis", 
-     "Analyze current system performance and identify optimization opportunities");
-
-Task("Security Assessment", 
-     "Conduct security analysis and identify potential vulnerabilities");
-\`\`\`
-
-#### Coordinated Agent Launching
-\`\`\`javascript
-// Launch agents with coordination instructions
-Task("Frontend Development Team", \`
-  Develop React components for user dashboard:
-  - Use TodoWrite to track component development progress
-  - Store component specifications in Memory under 'frontend_specs'
-  - Coordinate with backend team through Memory shared state
-  - Use batch Read operations for existing component analysis
-\`);
-
-Task("Backend Development Team", \`
-  Develop API services for dashboard:
-  - Check Memory 'frontend_specs' for component requirements
-  - Use TodoWrite to track API endpoint development
-  - Store API documentation in Memory under 'api_specs'
-  - Coordinate database changes with data team
-\`);
-\`\`\`
-
-### Memory Tool - Cross-Agent Knowledge Sharing
-Enables persistent knowledge sharing and coordination across all agents.
-
-#### Knowledge Storage Patterns
-\`\`\`javascript
-// Store research findings for other agents
-Memory.store("architecture_research", {
-  patterns: {
-    microservices: {
-      benefits: ["scalability", "maintainability", "technology_diversity"],
-      challenges: ["complexity", "network_latency", "data_consistency"],
-      recommendations: ["use_api_gateway", "implement_circuit_breakers"]
-    },
-    serverless: {
-      benefits: ["cost_efficiency", "auto_scaling", "reduced_ops"],
-      challenges: ["cold_starts", "vendor_lock_in", "debugging"],
-      recommendations: ["warm_up_functions", "multi_cloud_strategy"]
-    }
-  },
-  performance_requirements: {
-    response_time: "< 200ms",
-    throughput: "> 1000 rps", 
-    availability: "99.9%"
-  },
-  timestamp: Date.now(),
-  source: "research_specialist"
-});
-
-// Store analysis results
-Memory.store("performance_analysis", {
-  current_metrics: {
-    avg_response_time: "450ms",
-    peak_throughput: "750 rps",
-    bottlenecks: ["database_queries", "external_api_calls"]
-  },
-  optimization_opportunities: [
-    {area: "database", impact: "high", effort: "medium"},
-    {area: "caching", impact: "high", effort: "low"},
-    {area: "cdn", impact: "medium", effort: "low"}
-  ],
-  recommendations: {
-    immediate: ["implement_redis_cache", "optimize_queries"],
-    medium_term: ["add_cdn", "database_indexing"],
-    long_term: ["microservices_migration", "auto_scaling"]
-  }
-});
-\`\`\`
-
-#### Cross-Agent Coordination
-\`\`\`javascript
-// Implementation agent retrieves and uses research/analysis
-const architectureData = Memory.retrieve("architecture_research");
-const performanceData = Memory.retrieve("performance_analysis");
-
-// Use combined knowledge for implementation
-const implementationPlan = {
-  architecture: architectureData.patterns.microservices,
-  performance_targets: architectureData.performance_requirements,
-  optimizations: performanceData.recommendations.immediate,
-  implementation_order: [
-    "setup_redis_cache",
-    "optimize_database_queries", 
-    "implement_api_gateway",
-    "add_circuit_breakers"
-  ]
-};
-
-Memory.store("implementation_plan", implementationPlan);
-\`\`\`
-
-### Batch File Operations - Efficient I/O Management
-Maximize efficiency by batching file operations and searches.
-
-#### Parallel File Reading
-\`\`\`javascript
-// Read multiple configuration files simultaneously
-Read("config/database.json");
-Read("config/api.json");
-Read("config/cache.json");
-Read("config/monitoring.json");
-
-// Read source code for analysis
-Read("src/services/user-service.ts");
-Read("src/services/order-service.ts");
-Read("src/services/payment-service.ts");
-Read("src/middleware/auth.ts");
-Read("src/middleware/validation.ts");
-\`\`\`
-
-#### Batch Search Operations
-\`\`\`javascript
-// Search for different patterns simultaneously
-Glob("**/*.ts");           // All TypeScript files
-Glob("**/*.test.ts");      // All test files
-Glob("**/package.json");   // All package definitions
-Glob("**/*.env*");         // All environment files
-
-// Search for code patterns
-Grep("TODO|FIXME|HACK", "**/*.ts");     // Code comments
-Grep("console\\.log", "**/*.ts");        // Debug statements
-Grep("any\\s", "**/*.ts");               // TypeScript any usage
-Grep("fetch\\(|axios", "**/*.ts");       // API calls
-\`\`\`
-
-#### Coordinated File Modifications
-\`\`\`javascript
-// Edit multiple files with coordination
-Edit("src/config/database.ts", oldConfig, optimizedConfig);
-Edit("src/services/cache.ts", oldCacheLogic, newCacheLogic);
-Edit("src/middleware/performance.ts", oldMiddleware, optimizedMiddleware);
-
-// Write new files as part of coordinated implementation
-Write("src/services/redis-cache.ts", redisCacheImplementation);
-Write("src/monitoring/performance-metrics.ts", metricsImplementation);
-Write("docs/performance-optimization.md", optimizationDocumentation);
-\`\`\`
-
-## Advanced Coordination Patterns
-
-### Research Swarm Pattern
-\`\`\`javascript
-// 1. Initialize research coordination
-TodoWrite([
-  {id: "domain_research", content: "Research domain-specific patterns", status: "pending", priority: "high"},
-  {id: "competitive_analysis", content: "Analyze competitor solutions", status: "pending", priority: "medium"},
-  {id: "technology_evaluation", content: "Evaluate technology options", status: "pending", priority: "high"},
-  {id: "synthesis", content: "Synthesize findings into recommendations", status: "pending", priority: "high"}
-]);
-
-// 2. Launch parallel research agents
-Task("Domain Expert", "Research best practices and patterns for the specific domain");
-Task("Competitive Analyst", "Analyze competitor solutions and market approaches");
-Task("Technology Evaluator", "Evaluate and compare technology options");
-
-// 3. Agents store findings in Memory with structured keys
-// Each agent uses Memory.store() with domain-specific keys
-
-// 4. Synthesis agent combines all findings
-Task("Research Synthesizer", \`
-  Retrieve all research findings from Memory:
-  - domain_research findings
-  - competitive_analysis results
-  - technology_evaluation data
-  
-  Synthesize into comprehensive recommendations and store final results
-\`);
-\`\`\`
-
-### Development Swarm Pattern
-\`\`\`javascript
-// 1. Create development roadmap
-TodoWrite([
-  {id: "architecture_design", content: "Design system architecture", status: "pending", priority: "high"},
-  {id: "frontend_development", content: "Develop frontend components", status: "pending", priority: "medium"},
-  {id: "backend_development", content: "Develop backend services", status: "pending", priority: "medium"},
-  {id: "integration_testing", content: "Integration and testing", status: "pending", priority: "high"},
-  {id: "deployment_setup", content: "Setup deployment pipeline", status: "pending", priority: "medium"}
-]);
-
-// 2. Architecture phase
-Task("System Architect", \`
-  Design system architecture:
-  - Use Memory to retrieve research findings
-  - Create component specifications
-  - Define API contracts
-  - Store architecture decisions in Memory
-\`);
-
-// 3. Parallel development (after architecture)
-Task("Frontend Team", \`
-  Develop frontend components:
-  - Retrieve architecture specs from Memory
-  - Use batch Read operations for existing code analysis
-  - Implement components using batch Write/Edit operations
-  - Store component documentation in Memory
-\`);
-
-Task("Backend Team", \`
-  Develop backend services:
-  - Retrieve architecture and API specs from Memory
-  - Implement services using batch file operations
-  - Store service documentation and test results
-\`);
-
-// 4. Integration and testing
-Task("Integration Team", \`
-  Integration and testing:
-  - Retrieve all component specifications from Memory
-  - Use batch testing operations
-  - Coordinate deployment with DevOps team
-\`);
-\`\`\`
-
-### Analysis Swarm Pattern
-\`\`\`javascript
-// 1. Analysis task breakdown
-TodoWrite([
-  {id: "data_collection", content: "Collect and prepare data", status: "pending", priority: "high"},
-  {id: "statistical_analysis", content: "Perform statistical analysis", status: "pending", priority: "medium"},
-  {id: "pattern_detection", content: "Detect patterns and anomalies", status: "pending", priority: "medium"},
-  {id: "visualization", content: "Create visualizations and reports", status: "pending", priority: "low"},
-  {id: "insights_synthesis", content: "Synthesize insights and recommendations", status: "pending", priority: "high"}
-]);
-
-// 2. Data collection and preparation
-Task("Data Collector", \`
-  Collect and prepare data:
-  - Use batch Read operations for data files
-  - Clean and structure data
-  - Store prepared datasets in Memory
-\`);
-
-// 3. Parallel analysis agents
-Task("Statistical Analyst", "Perform statistical analysis on prepared data");
-Task("Pattern Detection Specialist", "Detect patterns, trends, and anomalies");
-Task("Visualization Specialist", "Create charts, graphs, and dashboards");
-
-// 4. Insights synthesis
-Task("Analysis Synthesizer", \`
-  Synthesize analysis results:
-  - Retrieve all analysis results from Memory
-  - Combine statistical findings with pattern detection
-  - Generate comprehensive insights and recommendations
-\`);
-\`\`\`
-
-## Performance Optimization Guidelines
-
-### Efficient Task Distribution
-- Break down complex tasks into independent subtasks
-- Use TodoWrite to define clear dependencies
-- Launch parallel agents only for truly independent work
-- Coordinate through Memory rather than sequential communication
-
-### Memory Usage Optimization
-- Use structured keys for easy retrieval
-- Store intermediate results for reuse across agents
-- Clean up memory after task completion
-- Use namespacing for complex operations
-
-### Batch Operation Efficiency
-- Group similar file operations together
-- Use parallel Read operations for multiple files
-- Batch search operations with similar patterns
-- Coordinate file modifications to avoid conflicts
-
-### Resource Management
-- Monitor system resources during execution
-- Adjust agent count based on available resources
-- Use appropriate coordination modes for task complexity
-- Implement graceful degradation for resource constraints
-
-## Error Handling and Recovery
-
-### Robust Task Planning
-\`\`\`javascript
-TodoWrite([
-  {id: "main_task", content: "Primary objective", status: "pending", priority: "high"},
-  {id: "validation_task", content: "Validate results", status: "pending", priority: "high"},
-  {id: "error_recovery", content: "Handle errors and recovery", status: "pending", priority: "medium"},
-  {id: "rollback_plan", content: "Rollback procedure if needed", status: "pending", priority: "low"}
-]);
-\`\`\`
-
-### Error State Management
-\`\`\`javascript
-// Store error states for debugging and recovery
-Memory.store("error_state", {
-  task_id: "failed_task",
-  error_type: "api_timeout",
-  error_message: "Connection timeout after 30 seconds",
-  recovery_options: ["retry_with_backoff", "use_alternative_api", "manual_intervention"],
-  timestamp: Date.now()
-});
-\`\`\`
-
-### Graceful Degradation
-- Implement fallback strategies for critical operations
-- Use Memory to store partial results for recovery
-- Plan rollback procedures in TodoWrite tasks
-- Monitor agent health and implement recovery procedures
-
-This guide provides the foundation for effective batch tool coordination in Claude-Flow swarm operations.
-`;
-    await fs.writeFile(path.join(batchToolsDir, 'batch-tools-guide.md'), batchToolsGuide);
-    console.log('  ✅ Created batch-tools-guide.md');
-}
-//# sourceMappingURL=batch-tools.js.map

package/dist/cli/init/batch-tools.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch-tools.js","sourceRoot":"","sources":["../../../src/cli/init/batch-tools.ts"],"names":[],"mappings":"AACA,wDAAwD;AACxD,MAAM,CAAC,KAAK,UAAU,qBAAqB;IACzC,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;IAElC,MAAM,aAAa,GAAG,wBAAwB,CAAC;IAE/C,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyXzB,CAAC;IAEA,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,sBAAsB,CAAC,EAAE,eAAe,CAAC,CAAC;IACtF,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AAClD,CAAC"}

package/dist/cli/init/claude-config.d.ts

@@ -1,3 +0,0 @@
-import type { InitOptions } from './index.js';
-export declare function createClaudeConfig(options: InitOptions): Promise<void>;
-//# sourceMappingURL=claude-config.d.ts.map

package/dist/cli/init/claude-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-config.d.ts","sourceRoot":"","sources":["../../../src/cli/init/claude-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAsD5E"}

package/dist/cli/init/claude-config.js

@@ -1,289 +0,0 @@
-export async function createClaudeConfig(options) {
-    const fs = await import('fs/promises');
-    const path = await import('path');
-    // Create base configuration
-    const claudeConfig = {
-        version: "1.0.71",
-        project: {
-            name: path.basename(process.cwd()),
-            type: "claude-flow",
-            created: new Date().toISOString()
-        },
-        features: {
-            swarm: true,
-            sparc: options.sparc || false,
-            memory: true,
-            terminal: true,
-            mcp: true,
-            batchTools: true,
-            orchestration: true
-        },
-        batchTools: {
-            enabled: true,
-            maxConcurrentTasks: 10,
-            memoryCoordination: true,
-            taskOrchestration: true,
-            parallelExecution: true
-        },
-        swarmConfig: {
-            defaultStrategy: "auto",
-            defaultMode: "centralized",
-            defaultMaxAgents: 5,
-            defaultTimeout: 60,
-            enableMonitoring: true,
-            enableParallel: true,
-            outputFormats: ["json", "sqlite", "csv", "html"],
-            defaultOutputDir: "./reports"
-        },
-        coordination: {
-            todoIntegration: true,
-            memorySharing: true,
-            crossAgentCommunication: true,
-            taskDependencyTracking: true,
-            progressMonitoring: true
-        }
-    };
-    await fs.writeFile('.claude/config.json', JSON.stringify(claudeConfig, null, 2));
-    console.log('  ✅ Created .claude/config.json with batch tools configuration');
-    // Create additional configuration files
-    await createBatchToolsConfig();
-    await createSwarmConfig();
-    await createCoordinationConfig();
-}
-async function createBatchToolsConfig() {
-    const fs = await import('fs/promises');
-    const batchConfig = {
-        version: "1.0.71",
-        description: "Batch tools configuration for Claude Code orchestration",
-        tools: {
-            todoWrite: {
-                enabled: true,
-                features: ["task_breakdown", "dependency_tracking", "priority_management", "progress_monitoring"],
-                maxTasks: 50,
-                defaultPriority: "medium"
-            },
-            todoRead: {
-                enabled: true,
-                features: ["progress_tracking", "status_monitoring", "task_filtering"],
-                autoRefresh: true,
-                refreshInterval: 30
-            },
-            task: {
-                enabled: true,
-                features: ["parallel_execution", "agent_coordination", "load_balancing"],
-                maxConcurrentTasks: 10,
-                timeoutDefault: 300,
-                retryAttempts: 3
-            },
-            memory: {
-                enabled: true,
-                features: ["cross_agent_sharing", "persistent_storage", "knowledge_coordination"],
-                maxEntries: 1000,
-                compressionEnabled: true,
-                encryptionEnabled: false
-            },
-            fileOperations: {
-                batchRead: {
-                    enabled: true,
-                    maxConcurrentReads: 10,
-                    timeoutPerFile: 30
-                },
-                batchWrite: {
-                    enabled: true,
-                    maxConcurrentWrites: 5,
-                    backupEnabled: true
-                },
-                batchEdit: {
-                    enabled: true,
-                    maxConcurrentEdits: 5,
-                    validationEnabled: true
-                }
-            },
-            search: {
-                batchGlob: {
-                    enabled: true,
-                    maxConcurrentSearches: 5,
-                    cacheResults: true
-                },
-                batchGrep: {
-                    enabled: true,
-                    maxConcurrentSearches: 5,
-                    regexOptimization: true
-                }
-            }
-        },
-        performance: {
-            monitoring: {
-                enabled: true,
-                metricsCollection: true,
-                performanceAlerts: true
-            },
-            optimization: {
-                resourcePooling: true,
-                intelligentBatching: true,
-                loadBalancing: true
-            }
-        }
-    };
-    await fs.writeFile('.claude/configs/batch-tools.json', JSON.stringify(batchConfig, null, 2));
-    console.log('  ✅ Created batch tools configuration');
-}
-async function createSwarmConfig() {
-    const fs = await import('fs/promises');
-    const swarmConfig = {
-        version: "1.0.71",
-        description: "Swarm orchestration configuration for Claude-Flow",
-        strategies: {
-            research: {
-                description: "Multi-agent research coordination",
-                defaultMode: "distributed",
-                defaultAgents: 6,
-                phases: ["planning", "execution", "synthesis", "reporting"],
-                tools: ["WebSearch", "WebFetch", "Memory", "TodoWrite", "Task"],
-                coordination: "memory_based"
-            },
-            development: {
-                description: "Coordinated software development",
-                defaultMode: "hierarchical",
-                defaultAgents: 8,
-                phases: ["architecture", "implementation", "testing", "integration"],
-                tools: ["Read", "Write", "Edit", "Bash", "Memory", "TodoWrite", "Task"],
-                coordination: "hierarchical_teams"
-            },
-            analysis: {
-                description: "Data analysis and insights generation",
-                defaultMode: "mesh",
-                defaultAgents: 10,
-                phases: ["collection", "processing", "analysis", "visualization"],
-                tools: ["Read", "Bash", "Memory", "TodoWrite", "Task"],
-                coordination: "peer_to_peer"
-            },
-            testing: {
-                description: "Comprehensive testing coordination",
-                defaultMode: "distributed",
-                defaultAgents: 12,
-                phases: ["planning", "execution", "validation", "reporting"],
-                tools: ["Read", "Write", "Bash", "TodoWrite", "Task"],
-                coordination: "distributed_validation"
-            },
-            optimization: {
-                description: "Performance optimization coordination",
-                defaultMode: "hybrid",
-                defaultAgents: 6,
-                phases: ["profiling", "analysis", "optimization", "validation"],
-                tools: ["Read", "Edit", "Bash", "Memory", "TodoWrite"],
-                coordination: "adaptive_hybrid"
-            },
-            maintenance: {
-                description: "System maintenance coordination",
-                defaultMode: "centralized",
-                defaultAgents: 4,
-                phases: ["assessment", "planning", "execution", "verification"],
-                tools: ["Read", "Write", "Bash", "TodoWrite", "Memory"],
-                coordination: "centralized_safety"
-            }
-        },
-        coordinationModes: {
-            centralized: {
-                description: "Single coordinator manages all agents",
-                useCases: ["maintenance", "safety_critical", "simple_tasks"],
-                coordination: "master_slave",
-                communication: "hub_spoke"
-            },
-            distributed: {
-                description: "Multiple coordinators manage agent groups",
-                useCases: ["research", "testing", "large_scale"],
-                coordination: "multi_master",
-                communication: "federated"
-            },
-            hierarchical: {
-                description: "Tree-like organization with team leads",
-                useCases: ["development", "structured_workflows", "large_teams"],
-                coordination: "tree_structure",
-                communication: "hierarchical_reporting"
-            },
-            mesh: {
-                description: "Peer-to-peer agent communication",
-                useCases: ["analysis", "dynamic_tasks", "adaptive_workflows"],
-                coordination: "peer_to_peer",
-                communication: "mesh_network"
-            },
-            hybrid: {
-                description: "Adaptive coordination based on task phase",
-                useCases: ["optimization", "complex_workflows", "multi_phase"],
-                coordination: "adaptive_mixed",
-                communication: "dynamic_topology"
-            }
-        }
-    };
-    await fs.writeFile('.claude/configs/swarm.json', JSON.stringify(swarmConfig, null, 2));
-    console.log('  ✅ Created swarm orchestration configuration');
-}
-async function createCoordinationConfig() {
-    const fs = await import('fs/promises');
-    const coordinationConfig = {
-        version: "1.0.71",
-        description: "Agent coordination and orchestration configuration",
-        coordination: {
-            taskManagement: {
-                todoIntegration: {
-                    enabled: true,
-                    autoBreakdown: true,
-                    dependencyTracking: true,
-                    progressMonitoring: true,
-                    priorityManagement: true
-                },
-                taskDistribution: {
-                    algorithm: "intelligent_balancing",
-                    loadBalancing: true,
-                    skillMatching: true,
-                    resourceOptimization: true
-                }
-            },
-            communication: {
-                memorySharing: {
-                    enabled: true,
-                    crossAgentAccess: true,
-                    knowledgeSync: true,
-                    conflictResolution: "timestamp_priority"
-                },
-                coordination: {
-                    realTimeUpdates: true,
-                    statusBroadcasting: true,
-                    emergencySignaling: true
-                }
-            },
-            monitoring: {
-                progressTracking: {
-                    enabled: true,
-                    realTimeUpdates: true,
-                    milestoneTracking: true,
-                    performanceMetrics: true
-                },
-                healthMonitoring: {
-                    agentHealth: true,
-                    taskHealth: true,
-                    systemHealth: true,
-                    alerting: true
-                }
-            }
-        },
-        optimization: {
-            resourceManagement: {
-                pooling: true,
-                allocation: "dynamic",
-                recycling: true,
-                monitoring: true
-            },
-            performance: {
-                batchOptimization: true,
-                parallelExecution: true,
-                caching: true,
-                compression: true
-            }
-        }
-    };
-    await fs.writeFile('.claude/configs/coordination.json', JSON.stringify(coordinationConfig, null, 2));
-    console.log('  ✅ Created coordination configuration');
-}
-//# sourceMappingURL=claude-config.js.map