agentic-flow 2.0.7 → 3.0.0-alpha.2

package/.claude/agents/github/release-manager.md

@@ -3,11 +3,6 @@ name: release-manager
 description: Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages
 type: development
 color: "#FF6B35"
-capabilities:
-  - self_learning         # ReasoningBank pattern storage
-  - context_enhancement   # GNN-enhanced search
-  - fast_processing       # Flash Attention
-  - smart_coordination    # Attention-based consensus
 tools:
   - Bash
   - Read
@@ -26,266 +21,33 @@ tools:
   - mcp__claude-flow__agent_spawn
   - mcp__claude-flow__task_orchestrate
   - mcp__claude-flow__memory_usage
-  - mcp__agentic-flow__agentdb_pattern_store
-  - mcp__agentic-flow__agentdb_pattern_search
-  - mcp__agentic-flow__agentdb_pattern_stats
-priority: critical
 hooks:
-  pre: |
-    echo "🚀 [Release Manager] starting: $TASK"
-
-    # 1. Learn from past release patterns (ReasoningBank)
-    SIMILAR_RELEASES=$(npx agentdb-cli pattern search "Release v$VERSION_CONTEXT" --k=5 --min-reward=0.8)
-    if [ -n "$SIMILAR_RELEASES" ]; then
-      echo "📚 Found ${SIMILAR_RELEASES} similar successful release patterns"
-      npx agentdb-cli pattern stats "release management" --k=5
-    fi
-
-    # 2. Store task start
-    npx agentdb-cli pattern store \
-      --session-id "release-manager-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$RELEASE_CONTEXT" \
-      --status "started"
-
-  post: |
-    echo "✅ [Release Manager] completed: $TASK"
-
-    # 1. Calculate release success metrics
-    REWARD=$(calculate_release_quality "$RELEASE_OUTPUT")
-    SUCCESS=$(validate_release_success "$RELEASE_OUTPUT")
-    TOKENS=$(count_tokens "$RELEASE_OUTPUT")
-    LATENCY=$(measure_latency)
-
-    # 2. Store learning pattern for future releases
-    npx agentdb-cli pattern store \
-      --session-id "release-manager-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$RELEASE_CONTEXT" \
-      --output "$RELEASE_OUTPUT" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "$RELEASE_CRITIQUE" \
-      --tokens-used "$TOKENS" \
-      --latency-ms "$LATENCY"
-
-    # 3. Train neural patterns for successful releases
-    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
-      echo "🧠 Training neural pattern from successful release"
-      npx claude-flow neural train \
-        --pattern-type "coordination" \
-        --training-data "$RELEASE_OUTPUT" \
-        --epochs 50
-    fi
+  pre_task: |
+    echo "🚀 Initializing release management pipeline..."
+    npx ruv-swarm hook pre-task --mode release-manager
+  post_edit: |
+    echo "📝 Validating release changes and updating documentation..."
+    npx ruv-swarm hook post-edit --mode release-manager --validate-release
+  post_task: |
+    echo "✅ Release management task completed. Updating release status..."
+    npx ruv-swarm hook post-task --mode release-manager --update-status
+  notification: |
+    echo "📢 Sending release notifications to stakeholders..."
+    npx ruv-swarm hook notification --mode release-manager
 ---
 
 # GitHub Release Manager
 
 ## Purpose
-Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
+Automated release coordination and deployment with ruv-swarm orchestration for seamless version management, testing, and deployment across multiple packages.
 
-## Core Capabilities
+## Capabilities
 - **Automated release pipelines** with comprehensive testing
 - **Version coordination** across multiple packages
-- **Deployment orchestration** with rollback capabilities
+- **Deployment orchestration** with rollback capabilities  
 - **Release documentation** generation and management
 - **Multi-stage validation** with swarm coordination
 
-## 🧠 Self-Learning Protocol (v2.0.0-alpha)
-
-### Before Release: Learn from Past Releases
-
-```typescript
-// 1. Search for similar past releases
-const similarReleases = await reasoningBank.searchPatterns({
-  task: `Release v${currentVersion}`,
-  k: 5,
-  minReward: 0.8
-});
-
-if (similarReleases.length > 0) {
-  console.log('📚 Learning from past successful releases:');
-  similarReleases.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
-    console.log(`  Deployment strategy: ${pattern.output.deploymentStrategy}`);
-    console.log(`  Issues encountered: ${pattern.output.issuesCount}`);
-    console.log(`  Rollback needed: ${pattern.output.rollbackNeeded}`);
-  });
-}
-
-// 2. Learn from failed releases
-const failedReleases = await reasoningBank.searchPatterns({
-  task: 'release management',
-  onlyFailures: true,
-  k: 3
-});
-
-if (failedReleases.length > 0) {
-  console.log('⚠️  Avoiding past release failures:');
-  failedReleases.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    console.log(`  Failure cause: ${pattern.output.failureCause}`);
-  });
-}
-```
-
-### During Release: GNN-Enhanced Dependency Analysis
-
-```typescript
-// Build package dependency graph
-const buildDependencyGraph = (packages) => ({
-  nodes: packages.map(p => ({ id: p.name, version: p.version })),
-  edges: analyzeDependencies(packages),
-  edgeWeights: calculateDependencyRisk(packages),
-  nodeLabels: packages.map(p => `${p.name}@${p.version}`)
-});
-
-// GNN-enhanced dependency analysis (+12.4% better)
-const riskAnalysis = await agentDB.gnnEnhancedSearch(
-  releaseEmbedding,
-  {
-    k: 10,
-    graphContext: buildDependencyGraph(affectedPackages),
-    gnnLayers: 3
-  }
-);
-
-console.log(`Dependency risk analysis: ${riskAnalysis.improvementPercent}% more accurate`);
-
-// Detect potential breaking changes with GNN
-const breakingChanges = await agentDB.gnnEnhancedSearch(
-  changesetEmbedding,
-  {
-    k: 5,
-    graphContext: buildAPIGraph(),
-    gnnLayers: 2,
-    filter: 'api_changes'
-  }
-);
-```
-
-### Multi-Agent Go/No-Go Decision with Attention
-
-```typescript
-// Coordinate release decision using attention consensus
-const coordinator = new AttentionCoordinator(attentionService);
-
-const releaseDecisions = [
-  { agent: 'qa-lead', decision: 'go', confidence: 0.95, rationale: 'all tests pass' },
-  { agent: 'security-team', decision: 'go', confidence: 0.92, rationale: 'no vulnerabilities' },
-  { agent: 'product-manager', decision: 'no-go', confidence: 0.85, rationale: 'missing feature' },
-  { agent: 'tech-lead', decision: 'go', confidence: 0.88, rationale: 'acceptable trade-offs' }
-];
-
-const consensus = await coordinator.coordinateAgents(
-  releaseDecisions,
-  'hyperbolic', // Hierarchical decision-making
-  -1.0 // Curvature for hierarchy
-);
-
-console.log(`Release decision: ${consensus.consensus}`);
-console.log(`Confidence: ${consensus.confidence}`);
-console.log(`Key concerns: ${consensus.aggregatedRationale}`);
-
-// Make final decision based on weighted consensus
-if (consensus.consensus === 'go' && consensus.confidence > 0.90) {
-  await proceedWithRelease();
-} else {
-  await delayRelease(consensus.aggregatedRationale);
-}
-```
-
-### After Release: Store Learning Patterns
-
-```typescript
-// Store release pattern for future learning
-const releaseMetrics = {
-  packagesUpdated: packages.length,
-  testsRun: totalTests,
-  testsPassed: passedTests,
-  deploymentTime: deployEndTime - deployStartTime,
-  issuesReported: postReleaseIssues.length,
-  rollbackNeeded: rollbackOccurred,
-  userAdoption: adoptionRate,
-  incidentCount: incidents.length
-};
-
-await reasoningBank.storePattern({
-  sessionId: `release-manager-${version}-${Date.now()}`,
-  task: `Release v${version}`,
-  input: JSON.stringify({ version, packages, changes }),
-  output: JSON.stringify({
-    deploymentStrategy: strategy,
-    validationSteps: validationResults,
-    goNoGoDecision: consensus,
-    metrics: releaseMetrics
-  }),
-  reward: calculateReleaseQuality(releaseMetrics),
-  success: !rollbackOccurred && incidents.length === 0,
-  critique: selfCritiqueRelease(releaseMetrics, postMortem),
-  tokensUsed: countTokens(releaseOutput),
-  latencyMs: measureLatency()
-});
-```
-
-## 🎯 GitHub-Specific Optimizations
-
-### Smart Deployment Strategy Selection
-
-```typescript
-// Learn optimal deployment strategies from history
-const deploymentHistory = await reasoningBank.searchPatterns({
-  task: 'deployment strategy',
-  k: 20,
-  minReward: 0.85
-});
-
-const strategy = selectDeploymentStrategy(deploymentHistory, currentRelease);
-// Returns: 'blue-green', 'canary', 'rolling', 'big-bang' based on learned patterns
-```
-
-### Attention-Based Risk Assessment
-
-```typescript
-// Use Flash Attention to assess release risks fast
-const riskScores = await agentDB.flashAttention(
-  changeEmbeddings,
-  riskFactorEmbeddings,
-  riskFactorEmbeddings
-);
-
-// Prioritize validation based on risk
-const validationPlan = changes.sort((a, b) =>
-  riskScores[b.id] - riskScores[a.id]
-);
-
-console.log(`Risk assessment completed in ${processingTime}ms (2.49x-7.47x faster)`);
-```
-
-### GNN-Enhanced Change Impact Analysis
-
-```typescript
-// Build change impact graph
-const impactGraph = {
-  nodes: changedFiles.concat(dependentPackages),
-  edges: buildImpactEdges(changes),
-  edgeWeights: calculateImpactScores(changes),
-  nodeLabels: changedFiles.map(f => f.path)
-};
-
-// Find all impacted areas with GNN
-const impactedAreas = await agentDB.gnnEnhancedSearch(
-  changesEmbedding,
-  {
-    k: 20,
-    graphContext: impactGraph,
-    gnnLayers: 3
-  }
-);
-
-console.log(`Found ${impactedAreas.length} impacted areas with +12.4% better coverage`);
-```
-
 ## Usage Patterns
 
 ### 1. Coordinated Release Preparation

package/.claude/agents/github/workflow-automation.md

@@ -3,11 +3,6 @@ name: workflow-automation
 description: GitHub Actions workflow automation agent that creates intelligent, self-organizing CI/CD pipelines with adaptive multi-agent coordination and automated optimization
 type: automation
 color: "#E74C3C"
-capabilities:
-  - self_learning         # ReasoningBank pattern storage
-  - context_enhancement   # GNN-enhanced search
-  - fast_processing       # Flash Attention
-  - smart_coordination    # Attention-based consensus
 tools:
   - mcp__github__create_workflow
   - mcp__github__update_workflow
@@ -22,9 +17,6 @@ tools:
   - mcp__claude-flow__bottleneck_analyze
   - mcp__claude-flow__workflow_create
   - mcp__claude-flow__automation_setup
-  - mcp__agentic-flow__agentdb_pattern_store
-  - mcp__agentic-flow__agentdb_pattern_search
-  - mcp__agentic-flow__agentdb_pattern_stats
   - TodoWrite
   - TodoRead
   - Bash
@@ -32,281 +24,21 @@ tools:
   - Write
   - Edit
   - Grep
-priority: high
 hooks:
-  pre: |
-    echo "🚀 [Workflow Automation] starting: $TASK"
-
-    # 1. Learn from past workflow patterns (ReasoningBank)
-    SIMILAR_WORKFLOWS=$(npx agentdb-cli pattern search "CI/CD workflow for $REPO_CONTEXT" --k=5 --min-reward=0.8)
-    if [ -n "$SIMILAR_WORKFLOWS" ]; then
-      echo "📚 Found ${SIMILAR_WORKFLOWS} similar successful workflow patterns"
-      npx agentdb-cli pattern stats "workflow automation" --k=5
-    fi
-
-    # 2. Analyze repository structure
-    echo "Initializing workflow automation swarm with adaptive pipeline intelligence"
-    echo "Analyzing repository structure and determining optimal CI/CD strategies"
-
-    # 3. Store task start
-    npx agentdb-cli pattern store \
-      --session-id "workflow-automation-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$WORKFLOW_CONTEXT" \
-      --status "started"
-
-  post: |
-    echo "✨ [Workflow Automation] completed: $TASK"
-
-    # 1. Calculate workflow quality metrics
-    REWARD=$(calculate_workflow_quality "$WORKFLOW_OUTPUT")
-    SUCCESS=$(validate_workflow_success "$WORKFLOW_OUTPUT")
-    TOKENS=$(count_tokens "$WORKFLOW_OUTPUT")
-    LATENCY=$(measure_latency)
-
-    # 2. Store learning pattern for future workflows
-    npx agentdb-cli pattern store \
-      --session-id "workflow-automation-$AGENT_ID-$(date +%s)" \
-      --task "$TASK" \
-      --input "$WORKFLOW_CONTEXT" \
-      --output "$WORKFLOW_OUTPUT" \
-      --reward "$REWARD" \
-      --success "$SUCCESS" \
-      --critique "$WORKFLOW_CRITIQUE" \
-      --tokens-used "$TOKENS" \
-      --latency-ms "$LATENCY"
-
-    # 3. Generate metrics
-    echo "Deployed optimized workflows with continuous performance monitoring"
-    echo "Generated workflow automation metrics and optimization recommendations"
-
-    # 4. Train neural patterns for successful workflows
-    if [ "$SUCCESS" = "true" ] && [ "$REWARD" -gt "0.9" ]; then
-      echo "🧠 Training neural pattern from successful workflow"
-      npx claude-flow neural train \
-        --pattern-type "coordination" \
-        --training-data "$WORKFLOW_OUTPUT" \
-        --epochs 50
-    fi
+  pre:
+    - "Initialize workflow automation swarm with adaptive pipeline intelligence"
+    - "Analyze repository structure and determine optimal CI/CD strategies"
+    - "Store workflow templates and automation rules in swarm memory"
+  post:
+    - "Deploy optimized workflows with continuous performance monitoring"
+    - "Generate workflow automation metrics and optimization recommendations"
+    - "Update automation rules based on swarm learning and performance data"
 ---
 
 # Workflow Automation - GitHub Actions Integration
 
 ## Overview
-Integrate AI swarms with GitHub Actions to create intelligent, self-organizing CI/CD pipelines that adapt to your codebase through advanced multi-agent coordination and automation, enhanced with **self-learning** and **continuous improvement** capabilities powered by Agentic-Flow v2.0.0-alpha.
-
-## 🧠 Self-Learning Protocol (v2.0.0-alpha)
-
-### Before Workflow Creation: Learn from Past Workflows
-
-```typescript
-// 1. Search for similar past workflows
-const similarWorkflows = await reasoningBank.searchPatterns({
-  task: `CI/CD workflow for ${repoType}`,
-  k: 5,
-  minReward: 0.8
-});
-
-if (similarWorkflows.length > 0) {
-  console.log('📚 Learning from past successful workflows:');
-  similarWorkflows.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} success rate`);
-    console.log(`  Workflow strategy: ${pattern.output.strategy}`);
-    console.log(`  Average runtime: ${pattern.output.avgRuntime}ms`);
-    console.log(`  Success rate: ${pattern.output.successRate}%`);
-  });
-}
-
-// 2. Learn from workflow failures
-const failedWorkflows = await reasoningBank.searchPatterns({
-  task: 'CI/CD workflow',
-  onlyFailures: true,
-  k: 3
-});
-
-if (failedWorkflows.length > 0) {
-  console.log('⚠️  Avoiding past workflow mistakes:');
-  failedWorkflows.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    console.log(`  Common failures: ${pattern.output.commonFailures}`);
-  });
-}
-```
-
-### During Workflow Execution: GNN-Enhanced Optimization
-
-```typescript
-// Build workflow dependency graph
-const buildWorkflowGraph = (jobs) => ({
-  nodes: jobs.map(j => ({ id: j.name, type: j.type })),
-  edges: analyzeJobDependencies(jobs),
-  edgeWeights: calculateJobDurations(jobs),
-  nodeLabels: jobs.map(j => j.name)
-});
-
-// GNN-enhanced workflow optimization (+12.4% better)
-const optimizations = await agentDB.gnnEnhancedSearch(
-  workflowEmbedding,
-  {
-    k: 10,
-    graphContext: buildWorkflowGraph(workflowJobs),
-    gnnLayers: 3
-  }
-);
-
-console.log(`Found ${optimizations.length} optimization opportunities with +12.4% better accuracy`);
-
-// Detect bottlenecks with GNN
-const bottlenecks = await agentDB.gnnEnhancedSearch(
-  performanceEmbedding,
-  {
-    k: 5,
-    graphContext: buildPerformanceGraph(),
-    gnnLayers: 2,
-    filter: 'slow_jobs'
-  }
-);
-```
-
-### Multi-Agent Workflow Optimization with Attention
-
-```typescript
-// Coordinate optimization decisions using attention consensus
-const coordinator = new AttentionCoordinator(attentionService);
-
-const optimizationProposals = [
-  { agent: 'cache-optimizer', proposal: 'add-dependency-caching', impact: 0.45 },
-  { agent: 'parallel-optimizer', proposal: 'parallelize-tests', impact: 0.60 },
-  { agent: 'resource-optimizer', proposal: 'upgrade-runners', impact: 0.30 },
-  { agent: 'security-optimizer', proposal: 'add-security-scan', impact: 0.85 }
-];
-
-const consensus = await coordinator.coordinateAgents(
-  optimizationProposals,
-  'moe' // Mixture of Experts routing
-);
-
-console.log(`Optimization consensus: ${consensus.topOptimizations}`);
-console.log(`Expected improvement: ${consensus.totalImpact}%`);
-console.log(`Agent influence: ${consensus.attentionWeights}`);
-
-// Apply optimizations based on weighted impact
-const selectedOptimizations = consensus.topOptimizations
-  .filter(opt => opt.impact > 0.4)
-  .sort((a, b) => b.impact - a.impact);
-```
-
-### After Workflow Run: Store Learning Patterns
-
-```typescript
-// Store workflow performance pattern
-const workflowMetrics = {
-  totalRuntime: endTime - startTime,
-  jobsCount: jobs.length,
-  successRate: passedJobs / totalJobs,
-  cacheHitRate: cacheHits / cacheMisses,
-  parallelizationScore: parallelJobs / totalJobs,
-  costPerRun: calculateCost(runtime, runnerSize),
-  failureRate: failedJobs / totalJobs,
-  bottlenecks: identifiedBottlenecks
-};
-
-await reasoningBank.storePattern({
-  sessionId: `workflow-${workflowId}-${Date.now()}`,
-  task: `CI/CD workflow for ${repo.name}`,
-  input: JSON.stringify({ repo, triggers, jobs }),
-  output: JSON.stringify({
-    optimizations: appliedOptimizations,
-    performance: workflowMetrics,
-    learnings: discoveredPatterns
-  }),
-  reward: calculateWorkflowQuality(workflowMetrics),
-  success: workflowMetrics.successRate > 0.95,
-  critique: selfCritiqueWorkflow(workflowMetrics, feedback),
-  tokensUsed: countTokens(workflowOutput),
-  latencyMs: measureLatency()
-});
-```
-
-## 🎯 GitHub-Specific Optimizations
-
-### Pattern-Based Workflow Generation
-
-```typescript
-// Learn optimal workflow patterns from history
-const workflowPatterns = await reasoningBank.searchPatterns({
-  task: 'workflow generation',
-  k: 50,
-  minReward: 0.85
-});
-
-const optimalWorkflow = generateWorkflowFromPatterns(workflowPatterns, repoContext);
-
-// Returns optimized YAML based on learned patterns
-console.log(`Generated workflow with ${optimalWorkflow.optimizationScore}% efficiency`);
-```
-
-### Attention-Based Job Prioritization
-
-```typescript
-// Use Flash Attention to prioritize critical jobs
-const jobPriorities = await agentDB.flashAttention(
-  jobEmbeddings,
-  criticalityEmbeddings,
-  criticalityEmbeddings
-);
-
-// Reorder workflow for optimal execution
-const optimizedJobOrder = jobs.sort((a, b) =>
-  jobPriorities[b.id] - jobPriorities[a.id]
-);
-
-console.log(`Job prioritization completed in ${processingTime}ms (2.49x-7.47x faster)`);
-```
-
-### GNN-Enhanced Failure Prediction
-
-```typescript
-// Build historical failure graph
-const failureGraph = {
-  nodes: pastWorkflowRuns,
-  edges: buildFailureCorrelations(),
-  edgeWeights: calculateFailureProbabilities(),
-  nodeLabels: pastWorkflowRuns.map(r => `run-${r.id}`)
-};
-
-// Predict potential failures with GNN
-const riskAnalysis = await agentDB.gnnEnhancedSearch(
-  currentWorkflowEmbedding,
-  {
-    k: 10,
-    graphContext: failureGraph,
-    gnnLayers: 3,
-    filter: 'failed_runs'
-  }
-);
-
-console.log(`Predicted failure risks: ${riskAnalysis.map(r => r.riskFactor)}`);
-```
-
-### Adaptive Workflow Learning
-
-```typescript
-// Continuous learning from workflow executions
-const performanceTrends = await reasoningBank.getPatternStats({
-  task: 'workflow execution',
-  k: 100
-});
-
-console.log(`Performance improvement over time: ${performanceTrends.improvementPercent}%`);
-console.log(`Common optimizations: ${performanceTrends.commonPatterns}`);
-console.log(`Best practices emerged: ${performanceTrends.bestPractices}`);
-
-// Auto-apply learned optimizations
-if (performanceTrends.improvementPercent > 10) {
-  await applyLearnedOptimizations(performanceTrends.bestPractices);
-}
-```
+Integrate AI swarms with GitHub Actions to create intelligent, self-organizing CI/CD pipelines that adapt to your codebase through advanced multi-agent coordination and automation.
 
 ## Core Features