moflo 4.8.31 → 4.8.33

package/.claude/skills/v3-memory-unification/SKILL.md

@@ -1,174 +0,0 @@
----
-name: "V3 Memory Unification"
-description: "Unify 6+ memory systems into AgentDB with HNSW indexing for 150x-12,500x search improvements. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend)."
----
-
-# V3 Memory Unification
-
-## What This Skill Does
-
-Consolidates disparate memory systems into unified AgentDB backend with HNSW vector search, achieving 150x-12,500x search performance improvements while maintaining backward compatibility.
-
-## Quick Start
-
-```bash
-# Initialize memory unification
-Task("Memory architecture", "Design AgentDB unification strategy", "v3-memory-specialist")
-
-# AgentDB integration
-Task("AgentDB setup", "Configure HNSW indexing and vector search", "v3-memory-specialist")
-
-# Data migration
-Task("Memory migration", "Migrate SQLite/Markdown to AgentDB", "v3-memory-specialist")
-```
-
-## Systems to Unify
-
-### Legacy Systems → AgentDB
-```
-┌─────────────────────────────────────────┐
-│  • MemoryManager (basic operations)     │
-│  • DistributedMemorySystem (clustering) │
-│  • SwarmMemory (agent-specific)         │
-│  • AdvancedMemoryManager (features)     │
-│  • SQLiteBackend (structured)           │
-│  • MarkdownBackend (file-based)         │
-│  • HybridBackend (combination)          │
-└─────────────────────────────────────────┘
-                    ↓
-┌─────────────────────────────────────────┐
-│       🚀 AgentDB with HNSW             │
-│  • 150x-12,500x faster search          │
-│  • Unified query interface             │
-│  • Cross-agent memory sharing          │
-│  • SONA learning integration           │
-└─────────────────────────────────────────┘
-```
-
-## Implementation Architecture
-
-### Unified Memory Service
-```typescript
-class UnifiedMemoryService implements IMemoryBackend {
-  constructor(
-    private agentdb: AgentDBAdapter,
-    private indexer: HNSWIndexer,
-    private migrator: DataMigrator
-  ) {}
-
-  async store(entry: MemoryEntry): Promise<void> {
-    await this.agentdb.store(entry);
-    await this.indexer.index(entry);
-  }
-
-  async query(query: MemoryQuery): Promise<MemoryEntry[]> {
-    if (query.semantic) {
-      return this.indexer.search(query); // 150x-12,500x faster
-    }
-    return this.agentdb.query(query);
-  }
-}
-```
-
-### HNSW Vector Search
-```typescript
-class HNSWIndexer {
-  constructor(dimensions: number = 1536) {
-    this.index = new HNSWIndex({
-      dimensions,
-      efConstruction: 200,
-      M: 16,
-      speedupTarget: '150x-12500x'
-    });
-  }
-
-  async search(query: MemoryQuery): Promise<MemoryEntry[]> {
-    const embedding = await this.embedContent(query.content);
-    const results = this.index.search(embedding, query.limit || 10);
-    return this.retrieveEntries(results);
-  }
-}
-```
-
-## Migration Strategy
-
-### Phase 1: Foundation
-```typescript
-// AgentDB adapter setup
-const agentdb = new AgentDBAdapter({
-  dimensions: 1536,
-  indexType: 'HNSW',
-  speedupTarget: '150x-12500x'
-});
-```
-
-### Phase 2: Data Migration
-```typescript
-// SQLite → AgentDB
-const migrateFromSQLite = async () => {
-  const entries = await sqlite.getAll();
-  for (const entry of entries) {
-    const embedding = await generateEmbedding(entry.content);
-    await agentdb.store({ ...entry, embedding });
-  }
-};
-
-// Markdown → AgentDB
-const migrateFromMarkdown = async () => {
-  const files = await glob('**/*.md');
-  for (const file of files) {
-    const content = await fs.readFile(file, 'utf-8');
-    await agentdb.store({
-      id: generateId(),
-      content,
-      embedding: await generateEmbedding(content),
-      metadata: { originalFile: file }
-    });
-  }
-};
-```
-
-## SONA Integration
-
-### Learning Pattern Storage
-```typescript
-class SONAMemoryIntegration {
-  async storePattern(pattern: LearningPattern): Promise<void> {
-    await this.memory.store({
-      id: pattern.id,
-      content: pattern.data,
-      metadata: {
-        sonaMode: pattern.mode,
-        reward: pattern.reward,
-        adaptationTime: pattern.adaptationTime
-      },
-      embedding: await this.generateEmbedding(pattern.data)
-    });
-  }
-
-  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {
-    return this.memory.query({
-      type: 'semantic',
-      content: query,
-      filters: { type: 'learning_pattern' }
-    });
-  }
-}
-```
-
-## Performance Targets
-
-- **Search Speed**: 150x-12,500x improvement via HNSW
-- **Memory Usage**: 50-75% reduction through optimization
-- **Query Latency**: <100ms for 1M+ entries
-- **Cross-Agent Sharing**: Real-time memory synchronization
-- **SONA Integration**: <0.05ms adaptation time
-
-## Success Metrics
-
-- [ ] All 7 legacy memory systems migrated to AgentDB
-- [ ] 150x-12,500x search performance validated
-- [ ] 50-75% memory usage reduction achieved
-- [ ] Backward compatibility maintained
-- [ ] SONA learning patterns integrated
-- [ ] Cross-agent memory sharing operational

package/.claude/skills/v3-performance-optimization/SKILL.md

@@ -1,390 +0,0 @@
----
-name: "V3 Performance Optimization"
-description: "Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
----
-
-# V3 Performance Optimization
-
-## What This Skill Does
-
-Validates and optimizes claude-flow v3 to achieve industry-leading performance through Flash Attention, AgentDB HNSW indexing, and comprehensive system optimization with continuous benchmarking.
-
-## Quick Start
-
-```bash
-# Initialize performance optimization
-Task("Performance baseline", "Establish v2 performance benchmarks", "v3-performance-engineer")
-
-# Target validation (parallel)
-Task("Flash Attention", "Validate 2.49x-7.47x speedup target", "v3-performance-engineer")
-Task("Search optimization", "Validate 150x-12,500x search improvement", "v3-performance-engineer")
-Task("Memory optimization", "Achieve 50-75% memory reduction", "v3-performance-engineer")
-```
-
-## Performance Target Matrix
-
-### Flash Attention Revolution
-```
-┌─────────────────────────────────────────┐
-│           FLASH ATTENTION               │
-├─────────────────────────────────────────┤
-│  Baseline: Standard attention           │
-│  Target:   2.49x - 7.47x speedup       │
-│  Memory:   50-75% reduction             │
-│  Latency:  Sub-millisecond processing   │
-└─────────────────────────────────────────┘
-```
-
-### Search Performance Revolution
-```
-┌─────────────────────────────────────────┐
-│            SEARCH OPTIMIZATION         │
-├─────────────────────────────────────────┤
-│  Current:  O(n) linear search           │
-│  Target:   150x - 12,500x improvement   │
-│  Method:   HNSW indexing                │
-│  Latency:  <100ms for 1M+ entries       │
-└─────────────────────────────────────────┘
-```
-
-## Comprehensive Benchmark Suite
-
-### Startup Performance
-```typescript
-class StartupBenchmarks {
-  async benchmarkColdStart(): Promise<BenchmarkResult> {
-    const startTime = performance.now();
-
-    await this.initializeCLI();
-    await this.initializeMCPServer();
-    await this.spawnTestAgent();
-
-    const totalTime = performance.now() - startTime;
-
-    return {
-      total: totalTime,
-      target: 500, // ms
-      achieved: totalTime < 500
-    };
-  }
-}
-```
-
-### Memory Operation Benchmarks
-```typescript
-class MemoryBenchmarks {
-  async benchmarkVectorSearch(): Promise<SearchBenchmark> {
-    const queries = this.generateTestQueries(10000);
-
-    // Baseline: Current linear search
-    const baselineTime = await this.timeOperation(() =>
-      this.currentMemory.searchAll(queries)
-    );
-
-    // Target: HNSW search
-    const hnswTime = await this.timeOperation(() =>
-      this.agentDBMemory.hnswSearchAll(queries)
-    );
-
-    const improvement = baselineTime / hnswTime;
-
-    return {
-      baseline: baselineTime,
-      hnsw: hnswTime,
-      improvement,
-      targetRange: [150, 12500],
-      achieved: improvement >= 150
-    };
-  }
-
-  async benchmarkMemoryUsage(): Promise<MemoryBenchmark> {
-    const baseline = process.memoryUsage().heapUsed;
-
-    await this.loadTestDataset();
-    const withData = process.memoryUsage().heapUsed;
-
-    await this.enableOptimization();
-    const optimized = process.memoryUsage().heapUsed;
-
-    const reduction = (withData - optimized) / withData;
-
-    return {
-      baseline,
-      withData,
-      optimized,
-      reductionPercent: reduction * 100,
-      targetReduction: [50, 75],
-      achieved: reduction >= 0.5
-    };
-  }
-}
-```
-
-### Swarm Coordination Benchmarks
-```typescript
-class SwarmBenchmarks {
-  async benchmark15AgentCoordination(): Promise<SwarmBenchmark> {
-    const agents = await this.spawn15Agents();
-
-    // Coordination latency
-    const coordinationTime = await this.timeOperation(() =>
-      this.coordinateSwarmTask(agents)
-    );
-
-    // Task decomposition
-    const decompositionTime = await this.timeOperation(() =>
-      this.decomposeComplexTask()
-    );
-
-    // Consensus achievement
-    const consensusTime = await this.timeOperation(() =>
-      this.achieveSwarmConsensus(agents)
-    );
-
-    return {
-      coordination: coordinationTime,
-      decomposition: decompositionTime,
-      consensus: consensusTime,
-      agentCount: 15,
-      efficiency: this.calculateEfficiency(agents)
-    };
-  }
-}
-```
-
-### Flash Attention Benchmarks
-```typescript
-class AttentionBenchmarks {
-  async benchmarkFlashAttention(): Promise<AttentionBenchmark> {
-    const sequences = this.generateSequences([512, 1024, 2048, 4096]);
-    const results = [];
-
-    for (const sequence of sequences) {
-      // Baseline attention
-      const baselineResult = await this.benchmarkStandardAttention(sequence);
-
-      // Flash attention
-      const flashResult = await this.benchmarkFlashAttention(sequence);
-
-      results.push({
-        sequenceLength: sequence.length,
-        speedup: baselineResult.time / flashResult.time,
-        memoryReduction: (baselineResult.memory - flashResult.memory) / baselineResult.memory,
-        targetSpeedup: [2.49, 7.47],
-        achieved: this.checkTarget(flashResult, [2.49, 7.47])
-      });
-    }
-
-    return {
-      results,
-      averageSpeedup: this.calculateAverage(results, 'speedup'),
-      averageMemoryReduction: this.calculateAverage(results, 'memoryReduction')
-    };
-  }
-}
-```
-
-### SONA Learning Benchmarks
-```typescript
-class SONABenchmarks {
-  async benchmarkAdaptationTime(): Promise<SONABenchmark> {
-    const scenarios = [
-      'pattern_recognition',
-      'task_optimization',
-      'error_correction',
-      'performance_tuning'
-    ];
-
-    const results = [];
-
-    for (const scenario of scenarios) {
-      const startTime = performance.hrtime.bigint();
-      await this.sona.adapt(scenario);
-      const endTime = performance.hrtime.bigint();
-
-      const adaptationTimeMs = Number(endTime - startTime) / 1000000;
-
-      results.push({
-        scenario,
-        adaptationTime: adaptationTimeMs,
-        target: 0.05, // ms
-        achieved: adaptationTimeMs <= 0.05
-      });
-    }
-
-    return {
-      scenarios: results,
-      averageTime: results.reduce((sum, r) => sum + r.adaptationTime, 0) / results.length,
-      successRate: results.filter(r => r.achieved).length / results.length
-    };
-  }
-}
-```
-
-## Performance Monitoring Dashboard
-
-### Real-time Metrics
-```typescript
-class PerformanceMonitor {
-  async collectMetrics(): Promise<PerformanceSnapshot> {
-    return {
-      timestamp: Date.now(),
-      flashAttention: await this.measureFlashAttention(),
-      searchPerformance: await this.measureSearchSpeed(),
-      memoryUsage: await this.measureMemoryEfficiency(),
-      startupTime: await this.measureStartupLatency(),
-      sonaAdaptation: await this.measureSONASpeed(),
-      swarmCoordination: await this.measureSwarmEfficiency()
-    };
-  }
-
-  async generateReport(): Promise<PerformanceReport> {
-    const snapshot = await this.collectMetrics();
-
-    return {
-      summary: this.generateSummary(snapshot),
-      achievements: this.checkTargetAchievements(snapshot),
-      trends: this.analyzeTrends(),
-      recommendations: this.generateOptimizations(),
-      regressions: await this.detectRegressions()
-    };
-  }
-}
-```
-
-### Continuous Regression Detection
-```typescript
-class PerformanceRegression {
-  async detectRegressions(): Promise<RegressionReport> {
-    const current = await this.runFullBenchmark();
-    const baseline = await this.getBaseline();
-
-    const regressions = [];
-
-    for (const [metric, currentValue] of Object.entries(current)) {
-      const baselineValue = baseline[metric];
-      const change = (currentValue - baselineValue) / baselineValue;
-
-      if (change < -0.05) { // 5% regression threshold
-        regressions.push({
-          metric,
-          baseline: baselineValue,
-          current: currentValue,
-          regressionPercent: change * 100,
-          severity: this.classifyRegression(change)
-        });
-      }
-    }
-
-    return {
-      hasRegressions: regressions.length > 0,
-      regressions,
-      recommendations: this.generateRegressionFixes(regressions)
-    };
-  }
-}
-```
-
-## Optimization Strategies
-
-### Memory Optimization
-```typescript
-class MemoryOptimization {
-  async optimizeMemoryUsage(): Promise<OptimizationResult> {
-    // Implement memory pooling
-    await this.setupMemoryPools();
-
-    // Enable garbage collection tuning
-    await this.optimizeGarbageCollection();
-
-    // Implement object reuse patterns
-    await this.setupObjectPools();
-
-    // Enable memory compression
-    await this.enableMemoryCompression();
-
-    return this.validateMemoryReduction();
-  }
-}
-```
-
-### CPU Optimization
-```typescript
-class CPUOptimization {
-  async optimizeCPUUsage(): Promise<OptimizationResult> {
-    // Implement worker thread pools
-    await this.setupWorkerThreads();
-
-    // Enable CPU-specific optimizations
-    await this.enableSIMDInstructions();
-
-    // Implement task batching
-    await this.optimizeTaskBatching();
-
-    return this.validateCPUImprovement();
-  }
-}
-```
-
-## Target Validation Framework
-
-### Performance Gates
-```typescript
-class PerformanceGates {
-  async validateAllTargets(): Promise<ValidationReport> {
-    const results = await Promise.all([
-      this.validateFlashAttention(),     // 2.49x-7.47x
-      this.validateSearchPerformance(),  // 150x-12,500x
-      this.validateMemoryReduction(),    // 50-75%
-      this.validateStartupTime(),        // <500ms
-      this.validateSONAAdaptation()      // <0.05ms
-    ]);
-
-    return {
-      allTargetsAchieved: results.every(r => r.achieved),
-      results,
-      overallScore: this.calculateOverallScore(results),
-      recommendations: this.generateRecommendations(results)
-    };
-  }
-}
-```
-
-## Success Metrics
-
-### Primary Targets
-- [ ] **Flash Attention**: 2.49x-7.47x speedup validated
-- [ ] **Search Performance**: 150x-12,500x improvement confirmed
-- [ ] **Memory Reduction**: 50-75% usage optimization achieved
-- [ ] **Startup Time**: <500ms cold start consistently
-- [ ] **SONA Adaptation**: <0.05ms learning response time
-- [ ] **15-Agent Coordination**: Efficient parallel execution
-
-### Continuous Monitoring
-- [ ] **Performance Dashboard**: Real-time metrics collection
-- [ ] **Regression Testing**: Automated performance validation
-- [ ] **Trend Analysis**: Performance evolution tracking
-- [ ] **Alert System**: Immediate regression notification
-
-## Related V3 Skills
-
-- `v3-integration-deep` - Performance integration with agentic-flow
-- `v3-memory-unification` - Memory performance optimization
-- `v3-swarm-coordination` - Swarm performance coordination
-- `v3-security-overhaul` - Secure performance patterns
-
-## Usage Examples
-
-### Complete Performance Validation
-```bash
-# Full performance suite
-npm run benchmark:v3
-
-# Specific target validation
-npm run benchmark:flash-attention
-npm run benchmark:agentdb-search
-npm run benchmark:memory-optimization
-
-# Continuous monitoring
-npm run monitor:performance
-```

package/.claude/skills/v3-security-overhaul/SKILL.md

@@ -1,82 +0,0 @@
----
-name: "V3 Security Overhaul"
-description: "Complete security architecture overhaul for claude-flow v3. Addresses critical CVEs (CVE-1, CVE-2, CVE-3) and implements secure-by-default patterns. Use for security-first v3 implementation."
----
-
-# V3 Security Overhaul
-
-## What This Skill Does
-
-Orchestrates comprehensive security overhaul for claude-flow v3, addressing critical vulnerabilities and establishing security-first development practices using specialized v3 security agents.
-
-## Quick Start
-
-```bash
-# Initialize V3 security domain (parallel)
-Task("Security architecture", "Design v3 threat model and security boundaries", "v3-security-architect")
-Task("CVE remediation", "Fix CVE-1, CVE-2, CVE-3 critical vulnerabilities", "security-auditor")
-Task("Security testing", "Implement TDD London School security framework", "test-architect")
-```
-
-## Critical Security Fixes
-
-### CVE-1: Vulnerable Dependencies
-```bash
-npm update @anthropic-ai/claude-code@^2.0.31
-npm audit --audit-level high
-```
-
-### CVE-2: Weak Password Hashing
-```typescript
-// ❌ Old: SHA-256 with hardcoded salt
-const hash = crypto.createHash('sha256').update(password + salt).digest('hex');
-
-// ✅ New: bcrypt with 12 rounds
-import bcrypt from 'bcrypt';
-const hash = await bcrypt.hash(password, 12);
-```
-
-### CVE-3: Hardcoded Credentials
-```typescript
-// ✅ Generate secure random credentials
-const apiKey = crypto.randomBytes(32).toString('hex');
-```
-
-## Security Patterns
-
-### Input Validation (Zod)
-```typescript
-import { z } from 'zod';
-
-const TaskSchema = z.object({
-  taskId: z.string().uuid(),
-  content: z.string().max(10000),
-  agentType: z.enum(['security', 'core', 'integration'])
-});
-```
-
-### Path Sanitization
-```typescript
-function securePath(userPath: string, allowedPrefix: string): string {
-  const resolved = path.resolve(allowedPrefix, userPath);
-  if (!resolved.startsWith(path.resolve(allowedPrefix))) {
-    throw new SecurityError('Path traversal detected');
-  }
-  return resolved;
-}
-```
-
-### Safe Command Execution
-```typescript
-import { execFile } from 'child_process';
-
-// ✅ Safe: No shell interpretation
-const { stdout } = await execFile('git', [userInput], { shell: false });
-```
-
-## Success Metrics
-
-- **Security Score**: 90/100 (npm audit + custom scans)
-- **CVE Resolution**: 100% of critical vulnerabilities fixed
-- **Test Coverage**: >95% security-critical code
-- **Implementation**: All secure patterns documented and tested