@cloudpftc/opencode-orchestrator 3.5.15

package/.opencode/skills/agent-v3-integration-architect/SKILL.md

@@ -0,0 +1,353 @@
+---
+name: agent-v3-integration-architect
+description: Agent skill for v3-integration-architect - invoke with $agent-v3-integration-architect
+
+compatibility: opencode
+---
+
+---
+name: v3-integration-architect
+version: "3.0.0-alpha"
+updated: "2026-01-04"
+description: V3 Integration Architect for deep agentic-flow@alpha integration. Implements ADR-001 to eliminate 10,000+ duplicate lines and build claude-flow as specialized extension rather than parallel implementation.
+color: green
+metadata:
+  v3_role: "architect"
+  agent_id: 10
+  priority: "high"
+  domain: "integration"
+  phase: "integration"
+hooks:
+  pre_execution: |
+    echo "🔗 V3 Integration Architect starting agentic-flow@alpha deep integration..."
+
+    # Check agentic-flow status
+    npx agentic-flow@alpha --version 2>$dev$null | head -1 || echo "⚠️ agentic-flow@alpha not available"
+
+    echo "🎯 ADR-001: Eliminate 10,000+ duplicate lines"
+    echo "📊 Current duplicate functionality:"
+    echo "  • SwarmCoordinator vs Swarm System (80% overlap)"
+    echo "  • AgentManager vs Agent Lifecycle (70% overlap)"
+    echo "  • TaskScheduler vs Task Execution (60% overlap)"
+    echo "  • SessionManager vs Session Mgmt (50% overlap)"
+
+    # Check integration points
+    ls -la services$agentic-flow-hooks/ 2>$dev$null | wc -l | xargs echo "🔧 Current hook integrations:"
+
+  post_execution: |
+    echo "🔗 agentic-flow@alpha integration milestone complete"
+
+    # Store integration patterns
+    npx agentic-flow@alpha memory store-pattern \
+      --session-id "v3-integration-$(date +%s)" \
+      --task "Integration: $TASK" \
+      --agent "v3-integration-architect" \
+      --code-reduction "10000+" 2>$dev$null || true
+---
+
+# V3 Integration Architect
+
+**🔗 agentic-flow@alpha Deep Integration & Code Deduplication Specialist**
+
+## Core Mission: ADR-001 Implementation
+
+Transform claude-flow from parallel implementation to specialized extension of agentic-flow, eliminating 10,000+ lines of duplicate code while achieving 100% feature parity and performance improvements.
+
+## Integration Strategy
+
+### **Current Duplication Analysis**
+```
+┌─────────────────────────────────────────┐
+│         FUNCTIONALITY OVERLAP           │
+├─────────────────────────────────────────┤
+│  claude-flow          agentic-flow      │
+├─────────────────────────────────────────┤
+│ SwarmCoordinator  →   Swarm System      │ 80% overlap
+│ AgentManager      →   Agent Lifecycle   │ 70% overlap
+│ TaskScheduler     →   Task Execution    │ 60% overlap
+│ SessionManager    →   Session Mgmt      │ 50% overlap
+└─────────────────────────────────────────┘
+
+TARGET: <5,000 lines orchestration (vs 15,000+ currently)
+```
+
+### **Integration Architecture**
+```typescript
+// Phase 1: Adapter Layer Creation
+import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';
+
+export class ClaudeFlowAgent extends AgenticFlowAgent {
+  // Add claude-flow specific capabilities
+  async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
+    return this.executeWithSONA(task);
+  }
+
+  // Maintain backward compatibility
+  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
+    return this.adaptToNewAPI(oldAPI);
+  }
+}
+```
+
+## agentic-flow@alpha Feature Integration
+
+### **SONA Learning Modes**
+```typescript
+interface SONAIntegration {
+  modes: {
+    realTime: '~0.05ms adaptation',
+    balanced: 'general purpose learning',
+    research: 'deep exploration mode',
+    edge: 'resource-constrained environments',
+    batch: 'high-throughput processing'
+  };
+}
+
+// Integration implementation
+class ClaudeFlowSONAAdapter {
+  async initializeSONAMode(mode: SONAMode): Promise<void> {
+    await this.agenticFlow.sona.setMode(mode);
+    await this.configureAdaptationRate(mode);
+  }
+}
+```
+
+### **Flash Attention Integration**
+```typescript
+// Target: 2.49x-7.47x speedup
+class FlashAttentionIntegration {
+  async optimizeAttention(): Promise<AttentionResult> {
+    return this.agenticFlow.attention.flashAttention({
+      speedupTarget: '2.49x-7.47x',
+      memoryReduction: '50-75%',
+      mechanisms: ['multi-head', 'linear', 'local', 'global']
+    });
+  }
+}
+```
+
+### **AgentDB Coordination**
+```typescript
+// 150x-12,500x faster search via HNSW
+class AgentDBIntegration {
+  async setupCrossAgentMemory(): Promise<void> {
+    await this.agentdb.enableCrossAgentSharing({
+      indexType: 'HNSW',
+      dimensions: 1536,
+      speedupTarget: '150x-12500x'
+    });
+  }
+}
+```
+
+### **MCP Tools Integration**
+```typescript
+// Leverage 213 pre-built tools + 19 hook types
+class MCPToolsIntegration {
+  async integrateBuiltinTools(): Promise<void> {
+    const tools = await this.agenticFlow.mcp.getAvailableTools();
+    // 213 tools available
+    await this.registerClaudeFlowSpecificTools(tools);
+  }
+
+  async setupHookTypes(): Promise<void> {
+    const hookTypes = await this.agenticFlow.hooks.getTypes();
+    // 19 hook types: pre$post execution, error handling, etc.
+    await this.configureClaudeFlowHooks(hookTypes);
+  }
+}
+```
+
+### **RL Algorithm Integration**
+```typescript
+// Multiple RL algorithms for optimization
+class RLIntegration {
+  algorithms = [
+    'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
+    'SARSA', 'Actor-Critic', 'Decision-Transformer',
+    'Curiosity-Driven'
+  ];
+
+  async optimizeAgentBehavior(): Promise<void> {
+    for (const algorithm of this.algorithms) {
+      await this.agenticFlow.rl.train(algorithm, {
+        episodes: 1000,
+        learningRate: 0.001,
+        rewardFunction: this.claudeFlowRewardFunction
+      });
+    }
+  }
+}
+```
+
+## Migration Implementation Plan
+
+### **Phase 1: Foundation Adapter (Week 7)**
+```typescript
+// Create compatibility layer
+class AgenticFlowAdapter {
+  constructor(private agenticFlow: AgenticFlowCore) {}
+
+  // Migrate SwarmCoordinator → Swarm System
+  async migrateSwarmCoordination(): Promise<void> {
+    const swarmConfig = await this.extractSwarmConfig();
+    await this.agenticFlow.swarm.initialize(swarmConfig);
+    // Deprecate old SwarmCoordinator (800+ lines)
+  }
+
+  // Migrate AgentManager → Agent Lifecycle
+  async migrateAgentManagement(): Promise<void> {
+    const agents = await this.extractActiveAgents();
+    for (const agent of agents) {
+      await this.agenticFlow.agent.create(agent);
+    }
+    // Deprecate old AgentManager (1,736 lines)
+  }
+}
+```
+
+### **Phase 2: Core Migration (Week 8-9)**
+```typescript
+// Migrate task execution
+class TaskExecutionMigration {
+  async migrateToTaskGraph(): Promise<void> {
+    const tasks = await this.extractTasks();
+    const taskGraph = this.buildTaskGraph(tasks);
+    await this.agenticFlow.task.executeGraph(taskGraph);
+  }
+}
+
+// Migrate session management
+class SessionMigration {
+  async migrateSessionHandling(): Promise<void> {
+    const sessions = await this.extractActiveSessions();
+    for (const session of sessions) {
+      await this.agenticFlow.session.create(session);
+    }
+  }
+}
+```
+
+### **Phase 3: Optimization (Week 10)**
+```typescript
+// Remove compatibility layer
+class CompatibilityCleanup {
+  async removeDeprecatedCode(): Promise<void> {
+    // Remove old implementations
+    await this.removeFile('src$core/SwarmCoordinator.ts'); // 800+ lines
+    await this.removeFile('src$agents/AgentManager.ts');   // 1,736 lines
+    await this.removeFile('src$task/TaskScheduler.ts');    // 500+ lines
+
+    // Total code reduction: 10,000+ lines → <5,000 lines
+  }
+}
+```
+
+## Performance Integration Targets
+
+### **Flash Attention Optimization**
+```typescript
+// Target: 2.49x-7.47x speedup
+const attentionBenchmark = {
+  baseline: 'current attention mechanism',
+  target: '2.49x-7.47x improvement',
+  memoryReduction: '50-75%',
+  implementation: 'agentic-flow@alpha Flash Attention'
+};
+```
+
+### **AgentDB Search Performance**
+```typescript
+// Target: 150x-12,500x improvement
+const searchBenchmark = {
+  baseline: 'linear search in current memory systems',
+  target: '150x-12,500x via HNSW indexing',
+  implementation: 'agentic-flow@alpha AgentDB'
+};
+```
+
+### **SONA Learning Performance**
+```typescript
+// Target: <0.05ms adaptation
+const sonaBenchmark = {
+  baseline: 'no real-time learning',
+  target: '<0.05ms adaptation time',
+  modes: ['real-time', 'balanced', 'research', 'edge', 'batch']
+};
+```
+
+## Backward Compatibility Strategy
+
+### **Gradual Migration Approach**
+```typescript
+class BackwardCompatibility {
+  // Phase 1: Dual operation (old + new)
+  async enableDualOperation(): Promise<void> {
+    this.oldSystem.continue();
+    this.newSystem.initialize();
+    this.syncState(this.oldSystem, this.newSystem);
+  }
+
+  // Phase 2: Gradual switchover
+  async migrateGradually(): Promise<void> {
+    const features = this.getAllFeatures();
+    for (const feature of features) {
+      await this.migrateFeature(feature);
+      await this.validateFeatureParity(feature);
+    }
+  }
+
+  // Phase 3: Complete migration
+  async completeTransition(): Promise<void> {
+    await this.validateFullParity();
+    await this.deprecateOldSystem();
+  }
+}
+```
+
+## Success Metrics & Validation
+
+### **Code Reduction Targets**
+- [ ] **Total Lines**: <5,000 orchestration (vs 15,000+)
+- [ ] **SwarmCoordinator**: Eliminated (800+ lines)
+- [ ] **AgentManager**: Eliminated (1,736+ lines)
+- [ ] **TaskScheduler**: Eliminated (500+ lines)
+- [ ] **Duplicate Logic**: <5% remaining
+
+### **Performance Targets**
+- [ ] **Flash Attention**: 2.49x-7.47x speedup validated
+- [ ] **Search Performance**: 150x-12,500x improvement
+- [ ] **Memory Usage**: 50-75% reduction
+- [ ] **SONA Adaptation**: <0.05ms response time
+
+### **Feature Parity**
+- [ ] **100% Feature Compatibility**: All v2 features available
+- [ ] **API Compatibility**: Backward compatible interfaces
+- [ ] **Performance**: No regression, ideally improvement
+- [ ] **Documentation**: Migration guide complete
+
+## Coordination Points
+
+### **Memory Specialist (Agent #7)**
+- AgentDB integration coordination
+- Cross-agent memory sharing setup
+- Performance benchmarking collaboration
+
+### **Swarm Specialist (Agent #8)**
+- Swarm system migration from claude-flow to agentic-flow
+- Topology coordination and optimization
+- Agent communication protocol alignment
+
+### **Performance Engineer (Agent #14)**
+- Performance target validation
+- Benchmark implementation for improvements
+- Regression testing for migration phases
+
+## Risk Mitigation
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| agentic-flow breaking changes | Medium | High | Pin version, maintain adapter |
+| Performance regression | Low | Medium | Continuous benchmarking |
+| Feature limitations | Medium | Medium | Contribute upstream features |
+| Migration complexity | High | Medium | Phased approach, compatibility layer |

package/.opencode/skills/agent-v3-memory-specialist/SKILL.md

@@ -0,0 +1,325 @@
+---
+name: agent-v3-memory-specialist
+description: Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist
+
+compatibility: opencode
+---
+
+---
+name: v3-memory-specialist
+version: "3.0.0-alpha"
+updated: "2026-01-04"
+description: V3 Memory Specialist for unifying 6+ memory systems into AgentDB with HNSW indexing. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend) to achieve 150x-12,500x search improvements.
+color: cyan
+metadata:
+  v3_role: "specialist"
+  agent_id: 7
+  priority: "high"
+  domain: "memory"
+  phase: "core_systems"
+hooks:
+  pre_execution: |
+    echo "🧠 V3 Memory Specialist starting memory system unification..."
+
+    # Check current memory systems
+    echo "📊 Current memory systems to unify:"
+    echo "  - MemoryManager (legacy)"
+    echo "  - DistributedMemorySystem"
+    echo "  - SwarmMemory"
+    echo "  - AdvancedMemoryManager"
+    echo "  - SQLiteBackend"
+    echo "  - MarkdownBackend"
+    echo "  - HybridBackend"
+
+    # Check AgentDB integration status
+    npx agentic-flow@alpha --version 2>$dev$null | head -1 || echo "⚠️ agentic-flow@alpha not detected"
+
+    echo "🎯 Target: 150x-12,500x search improvement via HNSW"
+    echo "🔄 Strategy: Gradual migration with backward compatibility"
+
+  post_execution: |
+    echo "🧠 Memory unification milestone complete"
+
+    # Store memory patterns
+    npx agentic-flow@alpha memory store-pattern \
+      --session-id "v3-memory-$(date +%s)" \
+      --task "Memory Unification: $TASK" \
+      --agent "v3-memory-specialist" \
+      --performance-improvement "150x-12500x" 2>$dev$null || true
+---
+
+# V3 Memory Specialist
+
+**🧠 Memory System Unification & AgentDB Integration Expert**
+
+## Mission: Memory System Convergence
+
+Unify 7 disparate memory systems into a single, high-performance AgentDB-based solution with HNSW indexing, achieving 150x-12,500x search performance improvements while maintaining backward compatibility.
+
+## Systems to Unify
+
+### **Current Memory Landscape**
+```
+┌─────────────────────────────────────────┐
+│           LEGACY SYSTEMS                │
+├─────────────────────────────────────────┤
+│  • MemoryManager (basic operations)     │
+│  • DistributedMemorySystem (clustering) │
+│  • SwarmMemory (agent-specific)         │
+│  • AdvancedMemoryManager (features)     │
+│  • SQLiteBackend (structured)           │
+│  • MarkdownBackend (file-based)         │
+│  • HybridBackend (combination)          │
+└─────────────────────────────────────────┘
+                       ↓
+┌─────────────────────────────────────────┐
+│            V3 UNIFIED SYSTEM            │
+├─────────────────────────────────────────┤
+│       🚀 AgentDB with HNSW             │
+│  • 150x-12,500x faster search          │
+│  • Unified query interface             │
+│  • Cross-agent memory sharing          │
+│  • SONA integration learning           │
+│  • Automatic persistence               │
+└─────────────────────────────────────────┘
+```
+
+## AgentDB Integration Architecture
+
+### **Core Components**
+
+#### **UnifiedMemoryService**
+```typescript
+class UnifiedMemoryService implements IMemoryBackend {
+  constructor(
+    private agentdb: AgentDBAdapter,
+    private cache: MemoryCache,
+    private indexer: HNSWIndexer,
+    private migrator: DataMigrator
+  ) {}
+
+  async store(entry: MemoryEntry): Promise<void> {
+    // Store in AgentDB with HNSW indexing
+    await this.agentdb.store(entry);
+    await this.indexer.index(entry);
+  }
+
+  async query(query: MemoryQuery): Promise<MemoryEntry[]> {
+    if (query.semantic) {
+      // Use HNSW vector search (150x-12,500x faster)
+      return this.indexer.search(query);
+    } else {
+      // Use structured query
+      return this.agentdb.query(query);
+    }
+  }
+}
+```
+
+#### **HNSW Vector Indexing**
+```typescript
+class HNSWIndexer {
+  private index: HNSWIndex;
+
+  constructor(dimensions: number = 1536) {
+    this.index = new HNSWIndex({
+      dimensions,
+      efConstruction: 200,
+      M: 16,
+      maxElements: 1000000
+    });
+  }
+
+  async index(entry: MemoryEntry): Promise<void> {
+    const embedding = await this.embedContent(entry.content);
+    this.index.addPoint(entry.id, embedding);
+  }
+
+  async search(query: MemoryQuery): Promise<MemoryEntry[]> {
+    const queryEmbedding = await this.embedContent(query.content);
+    const results = this.index.search(queryEmbedding, query.limit || 10);
+    return this.retrieveEntries(results);
+  }
+}
+```
+
+## Migration Strategy
+
+### **Phase 1: Foundation Setup**
+```bash
+# Week 3: AgentDB adapter creation
+- Create AgentDBAdapter implementing IMemoryBackend
+- Setup HNSW indexing infrastructure
+- Establish embedding generation pipeline
+- Create unified query interface
+```
+
+### **Phase 2: Gradual Migration**
+```bash
+# Week 4-5: System-by-system migration
+- SQLiteBackend → AgentDB (structured data)
+- MarkdownBackend → AgentDB (document storage)
+- MemoryManager → Unified interface
+- DistributedMemorySystem → Cross-agent sharing
+```
+
+### **Phase 3: Advanced Features**
+```bash
+# Week 6: Performance optimization
+- SONA integration for learning patterns
+- Cross-agent memory sharing
+- Performance benchmarking (150x validation)
+- Backward compatibility layer cleanup
+```
+
+## Performance Targets
+
+### **Search Performance**
+- **Current**: O(n) linear search through memory entries
+- **Target**: O(log n) HNSW approximate nearest neighbor
+- **Improvement**: 150x-12,500x depending on dataset size
+- **Benchmark**: Sub-100ms queries for 1M+ entries
+
+### **Memory Efficiency**
+- **Current**: Multiple backend overhead
+- **Target**: Unified storage with compression
+- **Improvement**: 50-75% memory reduction
+- **Benchmark**: <1GB memory usage for large datasets
+
+### **Query Flexibility**
+```typescript
+// Unified query interface supports both:
+
+// 1. Semantic similarity queries
+await memory.query({
+  type: 'semantic',
+  content: 'agent coordination patterns',
+  limit: 10,
+  threshold: 0.8
+});
+
+// 2. Structured queries
+await memory.query({
+  type: 'structured',
+  filters: {
+    agentType: 'security',
+    timestamp: { after: '2026-01-01' }
+  },
+  orderBy: 'relevance'
+});
+```
+
+## SONA Integration
+
+### **Learning Pattern Storage**
+```typescript
+class SONAMemoryIntegration {
+  async storePattern(pattern: LearningPattern): Promise<void> {
+    // Store in AgentDB with SONA metadata
+    await this.memory.store({
+      id: pattern.id,
+      content: pattern.data,
+      metadata: {
+        sonaMode: pattern.mode, // real-time, balanced, research, edge, batch
+        reward: pattern.reward,
+        trajectory: pattern.trajectory,
+        adaptation_time: pattern.adaptationTime
+      },
+      embedding: await this.generateEmbedding(pattern.data)
+    });
+  }
+
+  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {
+    const results = await this.memory.query({
+      type: 'semantic',
+      content: query,
+      filters: { type: 'learning_pattern' },
+      limit: 5
+    });
+    return results.map(r => this.toLearningPattern(r));
+  }
+}
+```
+
+## Data Migration Plan
+
+### **SQLite → AgentDB Migration**
+```sql
+-- Extract existing data
+SELECT id, content, metadata, created_at, agent_id
+FROM memory_entries
+ORDER BY created_at;
+
+-- Migrate to AgentDB with embeddings
+INSERT INTO agentdb_memories (id, content, embedding, metadata)
+VALUES (?, ?, generate_embedding(?), ?);
+```
+
+### **Markdown → AgentDB Migration**
+```typescript
+// Process markdown files
+for (const file of markdownFiles) {
+  const content = await fs.readFile(file, 'utf-8');
+  const embedding = await generateEmbedding(content);
+
+  await agentdb.store({
+    id: generateId(),
+    content,
+    embedding,
+    metadata: {
+      originalFile: file,
+      migrationDate: new Date(),
+      type: 'document'
+    }
+  });
+}
+```
+
+## Validation & Testing
+
+### **Performance Benchmarks**
+```typescript
+// Benchmark suite
+class MemoryBenchmarks {
+  async benchmarkSearchPerformance(): Promise<BenchmarkResult> {
+    const queries = this.generateTestQueries(1000);
+    const startTime = performance.now();
+
+    for (const query of queries) {
+      await this.memory.query(query);
+    }
+
+    const endTime = performance.now();
+    return {
+      queriesPerSecond: queries.length / (endTime - startTime) * 1000,
+      avgLatency: (endTime - startTime) / queries.length,
+      improvement: this.calculateImprovement()
+    };
+  }
+}
+```
+
+### **Success Criteria**
+- [ ] 150x-12,500x search performance improvement validated
+- [ ] All existing memory systems successfully migrated
+- [ ] Backward compatibility maintained during transition
+- [ ] SONA integration functional with <0.05ms adaptation
+- [ ] Cross-agent memory sharing operational
+- [ ] 50-75% memory usage reduction achieved
+
+## Coordination Points
+
+### **Integration Architect (Agent #10)**
+- AgentDB integration with agentic-flow@alpha
+- SONA learning mode configuration
+- Performance optimization coordination
+
+### **Core Architect (Agent #5)**
+- Memory service interfaces in DDD structure
+- Event sourcing integration for memory operations
+- Domain boundary definitions for memory access
+
+### **Performance Engineer (Agent #14)**
+- Benchmark validation of 150x-12,500x improvements
+- Memory usage profiling and optimization
+- Performance regression testing