@monoes/monomindcli 1.10.54 → 1.10.55

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

@@ -1,196 +0,0 @@
----
-name: 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)."
-triggers:
-  - unify memory
-  - migrate to AgentDB
-  - HNSW search setup
-  - memory fragmentation
-  - consolidate memory systems
-  - AgentDB migration
-  - memory backend unification
----
-
-# 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", "v1-memory-specialist")
-
-# AgentDB integration
-Task("AgentDB setup", "Configure HNSW indexing and vector search", "v1-memory-specialist")
-
-# Data migration
-Task("Memory migration", "Migrate SQLite/Markdown to AgentDB", "v1-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, // higher = better build quality, slower construction
-      M: 16,               // max bi-directional connections per node in the graph
-      ef: 100,             // search beam width — larger = higher recall, slower query
-    });
-  }
-
-  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();
-  // TODO: For large datasets (>10k records), implement:
-  // 1. Batch processing (e.g., 500 records per batch)
-  // 2. Checkpoint/resume via a migration_progress table
-  // 3. Progress reporting via onProgress callback
-  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");
-  // TODO: For large datasets (>10k records), implement:
-  // 1. Batch processing (e.g., 500 records per batch)
-  // 2. Checkpoint/resume via a migration_progress table
-  // 3. Progress reporting via onProgress callback
-  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/performance-optimization/SKILL.md

@@ -1,416 +0,0 @@
----
-name: performance-optimization
-description: "Achieve aggressive performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
-triggers:
-  - performance regression
-  - benchmark monomind
-  - Flash Attention target
-  - validate performance targets
-  - startup time too slow
-  - SONA adaptation slow
-  - performance suite
----
-
-# Performance Optimization
-
-## What This Skill Does
-
-Validates and optimizes monomind 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", "v1-performance-engineer")
-
-# Target validation (parallel)
-Task("Flash Attention", "Validate 2.49x-7.47x speedup target", "v1-performance-engineer")
-Task("Search optimization", "Validate 150x-12,500x search improvement", "v1-performance-engineer")
-Task("Memory optimization", "Achieve 50-75% memory reduction", "v1-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 Skills
-
-- `agentic-integration` - Performance integration architecture
-- `memory-unification` - Memory performance optimization
-- `swarm-coordination` - Swarm performance coordination
-- `security-hardening` - Secure performance patterns
-
-## Usage Examples
-
-### Complete Performance Validation
-
-```bash
-# Full performance suite
-npm run benchmark:v1
-
-# Specific target validation
-npm run benchmark:flash-attention
-npm run benchmark:agentdb-search
-npm run benchmark:memory-optimization
-
-# Continuous monitoring
-npm run monitor:performance
-```