@claude-flow/cli 3.10.36 → 3.10.37

package/.claude/skills/v3-integration-deep/SKILL.md

@@ -1,241 +1,241 @@
----
-name: "V3 Deep Integration"
-description: "Deep agentic-flow@alpha integration implementing ADR-001. Eliminates 10,000+ duplicate lines by building claude-flow as specialized extension rather than parallel implementation."
----
-
-# V3 Deep Integration
-
-## What This Skill Does
-
-Transforms claude-flow from parallel implementation to specialized extension of agentic-flow@alpha, eliminating massive code duplication while achieving performance improvements and feature parity.
-
-## Quick Start
-
-```bash
-# Initialize deep integration
-Task("Integration architecture", "Design agentic-flow@alpha adapter layer", "v3-integration-architect")
-
-# Feature integration (parallel)
-Task("SONA integration", "Integrate 5 SONA learning modes", "v3-integration-architect")
-Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v3-integration-architect")
-Task("AgentDB coordination", "Setup 150x-12,500x search", "v3-integration-architect")
-```
-
-## Code Deduplication Strategy
-
-### Current Overlap → Integration
-```
-┌─────────────────────────────────────────┐
-│  claude-flow          agentic-flow      │
-├─────────────────────────────────────────┤
-│ SwarmCoordinator  →   Swarm System      │ 80% overlap (eliminate)
-│ AgentManager      →   Agent Lifecycle   │ 70% overlap (eliminate)
-│ TaskScheduler     →   Task Execution    │ 60% overlap (eliminate)
-│ SessionManager    →   Session Mgmt      │ 50% overlap (eliminate)
-└─────────────────────────────────────────┘
-
-TARGET: <5,000 lines (vs 15,000+ currently)
-```
-
-## agentic-flow@alpha Feature Integration
-
-### SONA Learning Modes
-```typescript
-class SONAIntegration {
-  async initializeMode(mode: SONAMode): Promise<void> {
-    switch(mode) {
-      case 'real-time':   // ~0.05ms adaptation
-      case 'balanced':    // general purpose
-      case 'research':    // deep exploration
-      case 'edge':        // resource-constrained
-      case 'batch':       // high-throughput
-    }
-    await this.agenticFlow.sona.setMode(mode);
-  }
-}
-```
-
-### Flash Attention Integration
-```typescript
-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
-class AgentDBIntegration {
-  async setupCrossAgentMemory(): Promise<void> {
-    await this.agentdb.enableCrossAgentSharing({
-      indexType: 'HNSW',
-      speedupTarget: '150x-12500x',
-      dimensions: 1536
-    });
-  }
-}
-```
-
-### MCP Tools Integration
-```typescript
-class MCPToolsIntegration {
-  async integrateBuiltinTools(): Promise<void> {
-    // Leverage 213 pre-built tools
-    const tools = await this.agenticFlow.mcp.getAvailableTools();
-    await this.registerClaudeFlowSpecificTools(tools);
-
-    // Use 19 hook types
-    const hookTypes = await this.agenticFlow.hooks.getTypes();
-    await this.configureClaudeFlowHooks(hookTypes);
-  }
-}
-```
-
-## Migration Implementation
-
-### Phase 1: Adapter Layer
-```typescript
-import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';
-
-export class ClaudeFlowAgent extends AgenticFlowAgent {
-  async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
-    return this.executeWithSONA(task);
-  }
-
-  // Backward compatibility
-  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
-    return this.adaptToNewAPI(oldAPI);
-  }
-}
-```
-
-### Phase 2: System Migration
-```typescript
-class SystemMigration {
-  async migrateSwarmCoordination(): Promise<void> {
-    // Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
-    const swarmConfig = await this.extractSwarmConfig();
-    await this.agenticFlow.swarm.initialize(swarmConfig);
-  }
-
-  async migrateAgentManagement(): Promise<void> {
-    // Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
-    const agents = await this.extractActiveAgents();
-    for (const agent of agents) {
-      await this.agenticFlow.agent.create(agent);
-    }
-  }
-
-  async migrateTaskExecution(): Promise<void> {
-    // Replace TaskScheduler with agentic-flow task graph
-    const tasks = await this.extractTasks();
-    await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
-  }
-}
-```
-
-### Phase 3: Cleanup
-```typescript
-class CodeCleanup {
-  async removeDeprecatedCode(): Promise<void> {
-    // Remove massive duplicate 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 reduction: 10,000+ → <5,000 lines
-  }
-}
-```
-
-## RL Algorithm Integration
-
-```typescript
-class RLIntegration {
-  algorithms = [
-    'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
-    'SARSA', 'Actor-Critic', 'Decision-Transformer'
-  ];
-
-  async optimizeAgentBehavior(): Promise<void> {
-    for (const algorithm of this.algorithms) {
-      await this.agenticFlow.rl.train(algorithm, {
-        episodes: 1000,
-        rewardFunction: this.claudeFlowRewardFunction
-      });
-    }
-  }
-}
-```
-
-## Performance Integration
-
-### Flash Attention Targets
-```typescript
-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
-const searchBenchmark = {
-  baseline: 'linear search in current systems',
-  target: '150x-12,500x via HNSW indexing',
-  implementation: 'agentic-flow@alpha AgentDB'
-};
-```
-
-## Backward Compatibility
-
-### Gradual Migration
-```typescript
-class BackwardCompatibility {
-  // Phase 1: Dual operation
-  async enableDualOperation(): Promise<void> {
-    this.oldSystem.continue();
-    this.newSystem.initialize();
-    this.syncState(this.oldSystem, this.newSystem);
-  }
-
-  // Phase 2: Feature-by-feature migration
-  async migrateGradually(): Promise<void> {
-    const features = this.getAllFeatures();
-    for (const feature of features) {
-      await this.migrateFeature(feature);
-      await this.validateFeatureParity(feature);
-    }
-  }
-
-  // Phase 3: Complete transition
-  async completeTransition(): Promise<void> {
-    await this.validateFullParity();
-    await this.deprecateOldSystem();
-  }
-}
-```
-
-## Success Metrics
-
-- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
-- **Performance**: 2.49x-7.47x Flash Attention speedup
-- **Search**: 150x-12,500x AgentDB improvement
-- **Memory**: 50-75% usage reduction
-- **Feature Parity**: 100% v2 functionality maintained
-- **SONA**: <0.05ms adaptation time
-- **Integration**: All 213 MCP tools + 19 hook types available
-
-## Related V3 Skills
-
-- `v3-memory-unification` - Memory system integration
-- `v3-performance-optimization` - Performance target validation
-- `v3-swarm-coordination` - Swarm system migration
+---
+name: "V3 Deep Integration"
+description: "Deep agentic-flow@alpha integration implementing ADR-001. Eliminates 10,000+ duplicate lines by building claude-flow as specialized extension rather than parallel implementation."
+---
+
+# V3 Deep Integration
+
+## What This Skill Does
+
+Transforms claude-flow from parallel implementation to specialized extension of agentic-flow@alpha, eliminating massive code duplication while achieving performance improvements and feature parity.
+
+## Quick Start
+
+```bash
+# Initialize deep integration
+Task("Integration architecture", "Design agentic-flow@alpha adapter layer", "v3-integration-architect")
+
+# Feature integration (parallel)
+Task("SONA integration", "Integrate 5 SONA learning modes", "v3-integration-architect")
+Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v3-integration-architect")
+Task("AgentDB coordination", "Setup 150x-12,500x search", "v3-integration-architect")
+```
+
+## Code Deduplication Strategy
+
+### Current Overlap → Integration
+```
+┌─────────────────────────────────────────┐
+│  claude-flow          agentic-flow      │
+├─────────────────────────────────────────┤
+│ SwarmCoordinator  →   Swarm System      │ 80% overlap (eliminate)
+│ AgentManager      →   Agent Lifecycle   │ 70% overlap (eliminate)
+│ TaskScheduler     →   Task Execution    │ 60% overlap (eliminate)
+│ SessionManager    →   Session Mgmt      │ 50% overlap (eliminate)
+└─────────────────────────────────────────┘
+
+TARGET: <5,000 lines (vs 15,000+ currently)
+```
+
+## agentic-flow@alpha Feature Integration
+
+### SONA Learning Modes
+```typescript
+class SONAIntegration {
+  async initializeMode(mode: SONAMode): Promise<void> {
+    switch(mode) {
+      case 'real-time':   // ~0.05ms adaptation
+      case 'balanced':    // general purpose
+      case 'research':    // deep exploration
+      case 'edge':        // resource-constrained
+      case 'batch':       // high-throughput
+    }
+    await this.agenticFlow.sona.setMode(mode);
+  }
+}
+```
+
+### Flash Attention Integration
+```typescript
+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
+class AgentDBIntegration {
+  async setupCrossAgentMemory(): Promise<void> {
+    await this.agentdb.enableCrossAgentSharing({
+      indexType: 'HNSW',
+      speedupTarget: '150x-12500x',
+      dimensions: 1536
+    });
+  }
+}
+```
+
+### MCP Tools Integration
+```typescript
+class MCPToolsIntegration {
+  async integrateBuiltinTools(): Promise<void> {
+    // Leverage 213 pre-built tools
+    const tools = await this.agenticFlow.mcp.getAvailableTools();
+    await this.registerClaudeFlowSpecificTools(tools);
+
+    // Use 19 hook types
+    const hookTypes = await this.agenticFlow.hooks.getTypes();
+    await this.configureClaudeFlowHooks(hookTypes);
+  }
+}
+```
+
+## Migration Implementation
+
+### Phase 1: Adapter Layer
+```typescript
+import { Agent as AgenticFlowAgent } from 'agentic-flow@alpha';
+
+export class ClaudeFlowAgent extends AgenticFlowAgent {
+  async handleClaudeFlowTask(task: ClaudeTask): Promise<TaskResult> {
+    return this.executeWithSONA(task);
+  }
+
+  // Backward compatibility
+  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
+    return this.adaptToNewAPI(oldAPI);
+  }
+}
+```
+
+### Phase 2: System Migration
+```typescript
+class SystemMigration {
+  async migrateSwarmCoordination(): Promise<void> {
+    // Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
+    const swarmConfig = await this.extractSwarmConfig();
+    await this.agenticFlow.swarm.initialize(swarmConfig);
+  }
+
+  async migrateAgentManagement(): Promise<void> {
+    // Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
+    const agents = await this.extractActiveAgents();
+    for (const agent of agents) {
+      await this.agenticFlow.agent.create(agent);
+    }
+  }
+
+  async migrateTaskExecution(): Promise<void> {
+    // Replace TaskScheduler with agentic-flow task graph
+    const tasks = await this.extractTasks();
+    await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
+  }
+}
+```
+
+### Phase 3: Cleanup
+```typescript
+class CodeCleanup {
+  async removeDeprecatedCode(): Promise<void> {
+    // Remove massive duplicate 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 reduction: 10,000+ → <5,000 lines
+  }
+}
+```
+
+## RL Algorithm Integration
+
+```typescript
+class RLIntegration {
+  algorithms = [
+    'PPO', 'DQN', 'A2C', 'MCTS', 'Q-Learning',
+    'SARSA', 'Actor-Critic', 'Decision-Transformer'
+  ];
+
+  async optimizeAgentBehavior(): Promise<void> {
+    for (const algorithm of this.algorithms) {
+      await this.agenticFlow.rl.train(algorithm, {
+        episodes: 1000,
+        rewardFunction: this.claudeFlowRewardFunction
+      });
+    }
+  }
+}
+```
+
+## Performance Integration
+
+### Flash Attention Targets
+```typescript
+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
+const searchBenchmark = {
+  baseline: 'linear search in current systems',
+  target: '150x-12,500x via HNSW indexing',
+  implementation: 'agentic-flow@alpha AgentDB'
+};
+```
+
+## Backward Compatibility
+
+### Gradual Migration
+```typescript
+class BackwardCompatibility {
+  // Phase 1: Dual operation
+  async enableDualOperation(): Promise<void> {
+    this.oldSystem.continue();
+    this.newSystem.initialize();
+    this.syncState(this.oldSystem, this.newSystem);
+  }
+
+  // Phase 2: Feature-by-feature migration
+  async migrateGradually(): Promise<void> {
+    const features = this.getAllFeatures();
+    for (const feature of features) {
+      await this.migrateFeature(feature);
+      await this.validateFeatureParity(feature);
+    }
+  }
+
+  // Phase 3: Complete transition
+  async completeTransition(): Promise<void> {
+    await this.validateFullParity();
+    await this.deprecateOldSystem();
+  }
+}
+```
+
+## Success Metrics
+
+- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
+- **Performance**: 2.49x-7.47x Flash Attention speedup
+- **Search**: 150x-12,500x AgentDB improvement
+- **Memory**: 50-75% usage reduction
+- **Feature Parity**: 100% v2 functionality maintained
+- **SONA**: <0.05ms adaptation time
+- **Integration**: All 213 MCP tools + 19 hook types available
+
+## Related V3 Skills
+
+- `v3-memory-unification` - Memory system integration
+- `v3-performance-optimization` - Performance target validation
+- `v3-swarm-coordination` - Swarm system migration
 - `v3-security-overhaul` - Secure integration patterns