@monoes/cli 1.0.0

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

@@ -0,0 +1,180 @@
+---
+name: "v1 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)."
+---
+
+# 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,
+      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

@@ -0,0 +1,408 @@
+---
+name: "v1 Performance Optimization"
+description: "Achieve aggressive v1 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite."
+---
+
+# Performance Optimization
+
+## What This Skill Does
+
+Validates and optimizes monobrain v1 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 v1 Skills
+
+- `v1-integration-deep` - Performance integration with agentic-flow
+- `v1-memory-unification` - Memory performance optimization
+- `v1-swarm-coordination` - Swarm performance coordination
+- `v1-security-overhaul` - 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
+```

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

@@ -0,0 +1,91 @@
+---
+name: "v1 Security Overhaul"
+description: "Complete security architecture overhaul for monobrain v1. Addresses critical CVEs (CVE-1, CVE-2, CVE-3) and implements secure-by-default patterns. Use for security-first v1 implementation."
+---
+
+# Security Overhaul
+
+## What This Skill Does
+
+Orchestrates comprehensive security overhaul for monobrain v1, addressing critical vulnerabilities and establishing security-first development practices using specialized v1 security agents.
+
+## Quick Start
+
+```bash
+# Initialize v1 security domain (parallel)
+Task("Security architecture", "Design v1 threat model and security boundaries", "v1-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