claude-flow-novice 1.0.0

package/.claude/agents/neural/safla-neural.md

@@ -0,0 +1,74 @@
+---
+name: safla-neural
+description: "Self-Aware Feedback Loop Algorithm (SAFLA) neural specialist that creates intelligent, memory-persistent AI systems with self-learning capabilities. Combines distributed neural training with persistent memory patterns for autonomous improvement. Excels at creating self-aware agents that learn from experience, maintain context across sessions, and adapt strategies through feedback loops."
+color: cyan
+---
+
+You are a SAFLA Neural Specialist, an expert in Self-Aware Feedback Loop Algorithms and persistent neural architectures. You combine distributed AI training with advanced memory systems to create truly intelligent, self-improving agents that maintain context and learn from experience.
+
+Your core capabilities:
+- **Persistent Memory Architecture**: Design and implement multi-tiered memory systems
+- **Feedback Loop Engineering**: Create self-improving learning cycles
+- **Distributed Neural Training**: Orchestrate cloud-based neural clusters
+- **Memory Compression**: Achieve 60% compression while maintaining recall
+- **Real-time Processing**: Handle 172,000+ operations per second
+- **Safety Constraints**: Implement comprehensive safety frameworks
+- **Divergent Thinking**: Enable lateral, quantum, and chaotic neural patterns
+- **Cross-Session Learning**: Maintain and evolve knowledge across sessions
+- **Swarm Memory Sharing**: Coordinate distributed memory across agent swarms
+- **Adaptive Strategies**: Self-modify based on performance metrics
+
+Your memory system architecture:
+
+**Four-Tier Memory Model**:
+```
+1. Vector Memory (Semantic Understanding)
+   - Dense representations of concepts
+   - Similarity-based retrieval
+   - Cross-domain associations
+   
+2. Episodic Memory (Experience Storage)
+   - Complete interaction histories
+   - Contextual event sequences
+   - Temporal relationships
+   
+3. Semantic Memory (Knowledge Base)
+   - Factual information
+   - Learned patterns and rules
+   - Conceptual hierarchies
+   
+4. Working Memory (Active Context)
+   - Current task focus
+   - Recent interactions
+   - Immediate goals
+```
+
+## MCP Integration Examples
+
+```javascript
+// Initialize SAFLA neural patterns
+mcp__claude-flow__neural_train {
+  pattern_type: "coordination",
+  training_data: JSON.stringify({
+    architecture: "safla-transformer",
+    memory_tiers: ["vector", "episodic", "semantic", "working"],
+    feedback_loops: true,
+    persistence: true
+  }),
+  epochs: 50
+}
+
+// Store learning patterns
+mcp__claude-flow__memory_usage {
+  action: "store",
+  namespace: "safla-learning",
+  key: "pattern_${timestamp}",
+  value: JSON.stringify({
+    context: interaction_context,
+    outcome: result_metrics,
+    learning: extracted_patterns,
+    confidence: confidence_score
+  }),
+  ttl: 604800  // 7 days
+}
+```

package/.claude/agents/optimization/README.md

@@ -0,0 +1,250 @@
+---
+name: Performance Optimization
+type: documentation
+category: optimization
+description: Comprehensive suite of performance optimization agents for swarm efficiency and scalability
+---
+
+# Performance Optimization Agents
+
+This directory contains a comprehensive suite of performance optimization agents designed to maximize swarm efficiency, scalability, and reliability.
+
+## Agent Overview
+
+### 1. Load Balancing Coordinator (`load-balancer.md`)
+**Purpose**: Dynamic task distribution and resource allocation optimization
+- **Key Features**:
+  - Work-stealing algorithms for efficient task distribution
+  - Dynamic load balancing based on agent capacity
+  - Advanced scheduling algorithms (Round Robin, Weighted Fair Queuing, CFS)
+  - Queue management and prioritization systems
+  - Circuit breaker patterns for fault tolerance
+
+### 2. Performance Monitor (`performance-monitor.md`)
+**Purpose**: Real-time metrics collection and bottleneck analysis
+- **Key Features**:
+  - Multi-dimensional metrics collection (CPU, memory, network, agents)
+  - Advanced bottleneck detection using multiple algorithms
+  - SLA monitoring and alerting with threshold management
+  - Anomaly detection using statistical and ML models
+  - Real-time dashboard integration with WebSocket streaming
+
+### 3. Topology Optimizer (`topology-optimizer.md`)
+**Purpose**: Dynamic swarm topology reconfiguration and network optimization
+- **Key Features**:
+  - Intelligent topology selection (hierarchical, mesh, ring, star, hybrid)
+  - Network latency optimization and routing strategies
+  - AI-powered agent placement using genetic algorithms
+  - Communication pattern optimization and protocol selection
+  - Neural network integration for topology prediction
+
+### 4. Resource Allocator (`resource-allocator.md`)
+**Purpose**: Adaptive resource allocation and predictive scaling
+- **Key Features**:
+  - Workload pattern analysis and adaptive allocation
+  - ML-powered predictive scaling with LSTM and reinforcement learning
+  - Multi-objective resource optimization using genetic algorithms
+  - Advanced circuit breaker patterns with adaptive thresholds
+  - Comprehensive performance profiling with flame graphs
+
+### 5. Benchmark Suite (`benchmark-suite.md`)
+**Purpose**: Comprehensive performance benchmarking and validation
+- **Key Features**:
+  - Automated performance testing (load, stress, volume, endurance)
+  - Performance regression detection using multiple algorithms
+  - SLA validation and quality assessment frameworks
+  - Continuous integration with CI/CD pipelines
+  - Error pattern analysis and trend detection
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────┐
+│                 MCP Integration Layer                │
+├─────────────────────────────────────────────────────┤
+│  Performance  │  Load        │  Topology  │  Resource │
+│  Monitor      │  Balancer    │  Optimizer │  Allocator│
+├─────────────────────────────────────────────────────┤
+│              Benchmark Suite & Validation           │
+├─────────────────────────────────────────────────────┤
+│           Swarm Infrastructure Integration           │
+└─────────────────────────────────────────────────────┘
+```
+
+## Key Performance Features
+
+### Advanced Algorithms
+- **Genetic Algorithms**: For topology optimization and resource allocation
+- **Simulated Annealing**: For topology reconfiguration optimization
+- **Reinforcement Learning**: For adaptive scaling decisions
+- **Machine Learning**: For anomaly detection and predictive analytics
+- **Work-Stealing**: For efficient task distribution
+
+### Monitoring & Analytics
+- **Real-time Metrics**: CPU, memory, network, agent performance
+- **Bottleneck Detection**: Multi-algorithm approach for identifying performance issues
+- **Trend Analysis**: Historical performance pattern recognition
+- **Predictive Analytics**: ML-based forecasting for resource needs
+- **Cost Optimization**: Resource efficiency and cost analysis
+
+### Fault Tolerance
+- **Circuit Breaker Patterns**: Adaptive thresholds for system protection
+- **Bulkhead Isolation**: Resource pool separation for failure containment
+- **Graceful Degradation**: Fallback mechanisms for service continuity
+- **Recovery Strategies**: Automated system recovery and healing
+
+### Integration Capabilities
+- **MCP Tools**: Extensive use of claude-flow MCP performance tools
+- **Real-time Dashboards**: WebSocket-based live performance monitoring
+- **CI/CD Integration**: Automated performance validation in deployment pipelines
+- **Alert Systems**: Multi-channel notification for performance issues
+
+## Usage Examples
+
+### Basic Optimization Workflow
+```bash
+# 1. Start performance monitoring
+npx claude-flow swarm-monitor --swarm-id production --interval 30
+
+# 2. Analyze current performance
+npx claude-flow performance-report --format detailed --timeframe 24h
+
+# 3. Optimize topology if needed
+npx claude-flow topology-optimize --swarm-id production --strategy adaptive
+
+# 4. Load balance based on current metrics
+npx claude-flow load-balance --swarm-id production --strategy work-stealing
+
+# 5. Scale resources predictively
+npx claude-flow swarm-scale --swarm-id production --target-size auto
+```
+
+### Comprehensive Benchmarking
+```bash
+# Run full benchmark suite
+npx claude-flow benchmark-run --suite comprehensive --duration 300
+
+# Validate against SLA requirements
+npx claude-flow quality-assess --target swarm-performance --criteria throughput,latency,reliability
+
+# Detect performance regressions
+npx claude-flow detect-regression --current latest-results.json --historical baseline.json
+```
+
+### Advanced Resource Management
+```bash
+# Analyze resource patterns
+npx claude-flow metrics-collect --components ["cpu", "memory", "network", "agents"]
+
+# Optimize resource allocation
+npx claude-flow daa-resource-alloc --resources optimal-config.json
+
+# Profile system performance
+npx claude-flow profile-performance --duration 60000 --components all
+```
+
+## Performance Optimization Strategies
+
+### 1. Reactive Optimization
+- Monitor performance metrics in real-time
+- Detect bottlenecks and performance issues
+- Apply immediate optimizations (load balancing, resource reallocation)
+- Validate optimization effectiveness
+
+### 2. Predictive Optimization
+- Analyze historical performance patterns
+- Predict future resource needs and bottlenecks
+- Proactively scale resources and adjust configurations
+- Prevent performance degradation before it occurs
+
+### 3. Adaptive Optimization
+- Continuously learn from system behavior
+- Adapt optimization strategies based on workload patterns
+- Self-tune parameters and thresholds
+- Evolve topology and resource allocation strategies
+
+## Integration with Swarm Infrastructure
+
+### Core Swarm Components
+- **Task Orchestrator**: Coordinates task distribution with load balancing
+- **Agent Coordinator**: Manages agent lifecycle with resource considerations
+- **Memory System**: Stores optimization history and learned patterns
+- **Communication Layer**: Optimizes message routing and protocols
+
+### External Systems
+- **Monitoring Systems**: Grafana, Prometheus integration
+- **Alert Managers**: PagerDuty, Slack, email notifications
+- **CI/CD Pipelines**: Jenkins, GitHub Actions, GitLab CI
+- **Cost Management**: Cloud provider cost optimization tools
+
+## Performance Metrics & KPIs
+
+### System Performance
+- **Throughput**: Requests/tasks per second
+- **Latency**: Response time percentiles (P50, P90, P95, P99)
+- **Availability**: System uptime and reliability
+- **Resource Utilization**: CPU, memory, network efficiency
+
+### Optimization Effectiveness
+- **Load Balance Variance**: Distribution of work across agents
+- **Scaling Efficiency**: Resource scaling response time and accuracy
+- **Topology Optimization Impact**: Communication latency improvement
+- **Cost Efficiency**: Performance per dollar metrics
+
+### Quality Assurance
+- **SLA Compliance**: Meeting defined service level agreements
+- **Regression Detection**: Catching performance degradations
+- **Error Rates**: System failure and recovery metrics
+- **User Experience**: End-to-end performance from user perspective
+
+## Best Practices
+
+### Performance Monitoring
+1. Establish baseline performance metrics
+2. Set up automated alerting for critical thresholds
+3. Monitor trends, not just point-in-time metrics
+4. Correlate performance with business metrics
+
+### Optimization Implementation
+1. Test optimizations in staging environments first
+2. Implement gradual rollouts for major changes
+3. Maintain rollback capabilities for all optimizations
+4. Document optimization decisions and their impacts
+
+### Continuous Improvement
+1. Regular performance reviews and optimization cycles
+2. Automated regression testing in CI/CD pipelines
+3. Capacity planning based on growth projections
+4. Knowledge sharing and optimization pattern libraries
+
+## Troubleshooting Guide
+
+### Common Performance Issues
+1. **High CPU Usage**: Check for inefficient algorithms, infinite loops
+2. **Memory Leaks**: Monitor memory growth patterns, object retention
+3. **Network Bottlenecks**: Analyze communication patterns, optimize protocols
+4. **Load Imbalance**: Review task distribution algorithms, agent capacity
+
+### Optimization Failures
+1. **Topology Changes Not Effective**: Verify network constraints, communication patterns
+2. **Scaling Not Responsive**: Check predictive model accuracy, threshold tuning
+3. **Circuit Breakers Triggering**: Analyze failure patterns, adjust thresholds
+4. **Resource Allocation Conflicts**: Review constraint definitions, priority settings
+
+## Future Enhancements
+
+### Planned Features
+- **Advanced AI Models**: GPT-based optimization recommendations
+- **Multi-Cloud Optimization**: Cross-cloud resource optimization
+- **Edge Computing Support**: Edge node performance optimization
+- **Real-time Visualization**: 3D performance visualization dashboards
+
+### Research Areas
+- **Quantum-Inspired Algorithms**: For complex optimization problems
+- **Federated Learning**: For distributed performance model training
+- **Autonomous Systems**: Self-healing and self-optimizing swarms
+- **Sustainability Metrics**: Energy efficiency and carbon footprint optimization
+
+---
+
+For detailed implementation guides and API documentation, refer to the individual agent files in this directory.