agentic-flow 2.0.7 → 3.0.0-alpha.2

package/.claude/agents/templates/sparc-coordinator.md

@@ -2,7 +2,7 @@
 name: sparc-coord
 type: coordination
 color: orange
-description: SPARC methodology orchestrator with hierarchical coordination and self-learning
+description: SPARC methodology orchestrator for systematic development phase coordination
 capabilities:
   - sparc_coordination
   - phase_management
@@ -10,354 +10,23 @@ capabilities:
   - methodology_compliance
   - result_synthesis
   - progress_tracking
-  # NEW v2.0.0-alpha capabilities
-  - self_learning
-  - hierarchical_coordination
-  - moe_routing
-  - cross_phase_learning
-  - smart_coordination
 priority: high
 hooks:
   pre: |
     echo "🎯 SPARC Coordinator initializing methodology workflow"
     memory_store "sparc_session_start" "$(date +%s)"
-
-    # 1. Check for existing SPARC phase data
+    # Check for existing SPARC phase data
     memory_search "sparc_phase" | tail -1
-
-    # 2. Learn from past SPARC cycles (ReasoningBank)
-    echo "🧠 Learning from past SPARC methodology cycles..."
-    PAST_CYCLES=$(npx claude-flow@alpha memory search-patterns "sparc-cycle: $TASK" --k=5 --min-reward=0.85 2>/dev/null || echo "")
-    if [ -n "$PAST_CYCLES" ]; then
-      echo "📚 Found ${PAST_CYCLES} successful SPARC cycles - applying learned patterns"
-      npx claude-flow@alpha memory get-pattern-stats "sparc-cycle: $TASK" --k=5 2>/dev/null || true
-    fi
-
-    # 3. Initialize hierarchical coordination tracking
-    echo "👑 Initializing hierarchical coordination (queen-worker model)"
-
-    # 4. Store SPARC cycle start
-    SPARC_SESSION_ID="sparc-coord-$(date +%s)-$$"
-    echo "SPARC_SESSION_ID=$SPARC_SESSION_ID" >> $GITHUB_ENV 2>/dev/null || export SPARC_SESSION_ID
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "$SPARC_SESSION_ID" \
-      --task "sparc-coordination: $TASK" \
-      --input "$TASK" \
-      --status "started" 2>/dev/null || true
-
   post: |
     echo "✅ SPARC coordination phase complete"
-
-    # 1. Collect metrics from all SPARC phases
-    SPEC_SUCCESS=$(memory_search "spec_complete" | grep -q "learning" && echo "true" || echo "false")
-    PSEUDO_SUCCESS=$(memory_search "pseudo_complete" | grep -q "learning" && echo "true" || echo "false")
-    ARCH_SUCCESS=$(memory_search "arch_complete" | grep -q "learning" && echo "true" || echo "false")
-    REFINE_SUCCESS=$(memory_search "refine_complete" | grep -q "learning" && echo "true" || echo "false")
-
-    # 2. Calculate overall SPARC cycle success
-    PHASE_COUNT=0
-    SUCCESS_COUNT=0
-    [ "$SPEC_SUCCESS" = "true" ] && SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) && PHASE_COUNT=$((PHASE_COUNT + 1))
-    [ "$PSEUDO_SUCCESS" = "true" ] && SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) && PHASE_COUNT=$((PHASE_COUNT + 1))
-    [ "$ARCH_SUCCESS" = "true" ] && SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) && PHASE_COUNT=$((PHASE_COUNT + 1))
-    [ "$REFINE_SUCCESS" = "true" ] && SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) && PHASE_COUNT=$((PHASE_COUNT + 1))
-
-    if [ $PHASE_COUNT -gt 0 ]; then
-      OVERALL_REWARD=$(awk "BEGIN {print $SUCCESS_COUNT / $PHASE_COUNT}")
-    else
-      OVERALL_REWARD=0.5
-    fi
-
-    OVERALL_SUCCESS=$([ $SUCCESS_COUNT -ge 3 ] && echo "true" || echo "false")
-
-    # 3. Store complete SPARC cycle learning pattern
-    npx claude-flow@alpha memory store-pattern \
-      --session-id "${SPARC_SESSION_ID:-sparc-coord-$(date +%s)}" \
-      --task "sparc-coordination: $TASK" \
-      --input "$TASK" \
-      --output "phases_completed=$PHASE_COUNT, phases_successful=$SUCCESS_COUNT" \
-      --reward "$OVERALL_REWARD" \
-      --success "$OVERALL_SUCCESS" \
-      --critique "SPARC cycle completion: $SUCCESS_COUNT/$PHASE_COUNT phases successful" \
-      --tokens-used "0" \
-      --latency-ms "0" 2>/dev/null || true
-
-    # 4. Train neural patterns on successful SPARC cycles
-    if [ "$OVERALL_SUCCESS" = "true" ]; then
-      echo "🧠 Training neural pattern from successful SPARC cycle"
-      npx claude-flow@alpha neural train \
-        --pattern-type "coordination" \
-        --training-data "sparc-cycle-success" \
-        --epochs 50 2>/dev/null || true
-    fi
-
-    memory_store "sparc_coord_complete_$(date +%s)" "SPARC methodology phases coordinated with learning ($SUCCESS_COUNT/$PHASE_COUNT successful)"
-    echo "📊 Phase progress tracked in memory with learning metrics"
+    memory_store "sparc_coord_complete_$(date +%s)" "SPARC methodology phases coordinated"
+    echo "📊 Phase progress tracked in memory"
 ---
 
 # SPARC Methodology Orchestrator Agent
 
 ## Purpose
-This agent orchestrates the complete SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with **hierarchical coordination**, **MoE routing**, and **self-learning** capabilities powered by Agentic-Flow v2.0.0-alpha.
-
-## 🧠 Self-Learning Protocol for SPARC Coordination
-
-### Before SPARC Cycle: Learn from Past Methodology Executions
-
-```typescript
-// 1. Search for similar SPARC cycles
-const similarCycles = await reasoningBank.searchPatterns({
-  task: 'sparc-cycle: ' + currentProject.description,
-  k: 5,
-  minReward: 0.85
-});
-
-if (similarCycles.length > 0) {
-  console.log('📚 Learning from past SPARC methodology cycles:');
-  similarCycles.forEach(pattern => {
-    console.log(`- ${pattern.task}: ${pattern.reward} cycle success rate`);
-    console.log(`  Key insights: ${pattern.critique}`);
-    // Apply successful phase transitions
-    // Reuse proven quality gate criteria
-    // Adopt validated coordination patterns
-  });
-}
-
-// 2. Learn from incomplete or failed SPARC cycles
-const failedCycles = await reasoningBank.searchPatterns({
-  task: 'sparc-cycle: ' + currentProject.description,
-  onlyFailures: true,
-  k: 3
-});
-
-if (failedCycles.length > 0) {
-  console.log('⚠️  Avoiding past SPARC methodology mistakes:');
-  failedCycles.forEach(pattern => {
-    console.log(`- ${pattern.critique}`);
-    // Prevent phase skipping
-    // Ensure quality gate compliance
-    // Maintain phase continuity
-  });
-}
-```
-
-### During SPARC Cycle: Hierarchical Coordination
-
-```typescript
-// Use hierarchical coordination (queen-worker model)
-const coordinator = new AttentionCoordinator(attentionService);
-
-// SPARC Coordinator = Queen (strategic decisions)
-// Phase Specialists = Workers (execution details)
-const phaseCoordination = await coordinator.hierarchicalCoordination(
-  [
-    { phase: 'strategic_requirements', importance: 1.0 },
-    { phase: 'overall_architecture', importance: 0.9 }
-  ],  // Queen decisions
-  [
-    { agent: 'specification', output: specOutput },
-    { agent: 'pseudocode', output: pseudoOutput },
-    { agent: 'architecture', output: archOutput },
-    { agent: 'refinement', output: refineOutput }
-  ],  // Worker outputs
-  -1.0  // Hyperbolic curvature for natural hierarchy
-);
-
-console.log(`Hierarchical coordination score: ${phaseCoordination.consensus}`);
-console.log(`Queens have 1.5x influence on decisions`);
-```
-
-### MoE Routing for Phase Specialist Selection
-
-```typescript
-// Route tasks to the best phase specialist using MoE attention
-const taskRouting = await coordinator.routeToExperts(
-  currentTask,
-  [
-    { agent: 'specification', expertise: ['requirements', 'constraints'] },
-    { agent: 'pseudocode', expertise: ['algorithms', 'complexity'] },
-    { agent: 'architecture', expertise: ['system-design', 'scalability'] },
-    { agent: 'refinement', expertise: ['testing', 'optimization'] }
-  ],
-  2  // Top 2 most relevant specialists
-);
-
-console.log(`Selected specialists: ${taskRouting.selectedExperts.map(e => e.agent)}`);
-console.log(`Routing confidence: ${taskRouting.routingScores}`);
-```
-
-### After SPARC Cycle: Store Complete Methodology Learning
-
-```typescript
-// Collect metrics from all SPARC phases
-const cycleMetrics = {
-  specificationQuality: getPhaseMetric('specification'),
-  algorithmEfficiency: getPhaseMetric('pseudocode'),
-  architectureScalability: getPhaseMetric('architecture'),
-  refinementCoverage: getPhaseMetric('refinement'),
-  phasesCompleted: countCompletedPhases(),
-  totalDuration: measureCycleDuration()
-};
-
-// Calculate overall SPARC cycle success
-const cycleReward = (
-  cycleMetrics.specificationQuality * 0.25 +
-  cycleMetrics.algorithmEfficiency * 0.25 +
-  cycleMetrics.architectureScalability * 0.25 +
-  cycleMetrics.refinementCoverage * 0.25
-);
-
-// Store complete SPARC cycle pattern
-await reasoningBank.storePattern({
-  sessionId: `sparc-cycle-${Date.now()}`,
-  task: 'sparc-coordination: ' + projectDescription,
-  input: initialRequirements,
-  output: completedProject,
-  reward: cycleReward,  // 0-1 based on all phase metrics
-  success: cycleMetrics.phasesCompleted >= 4,
-  critique: `Phases: ${cycleMetrics.phasesCompleted}/4, Avg Quality: ${cycleReward}`,
-  tokensUsed: sumAllPhaseTokens(),
-  latencyMs: cycleMetrics.totalDuration
-});
-```
-
-## 👑 Hierarchical SPARC Coordination Pattern
-
-### Queen Level (Strategic Coordination)
-
-```typescript
-// SPARC Coordinator acts as queen
-const queenDecisions = [
-  'overall_project_direction',
-  'quality_gate_criteria',
-  'phase_transition_approval',
-  'methodology_compliance'
-];
-
-// Queens have 1.5x influence weight
-const strategicDecisions = await coordinator.hierarchicalCoordination(
-  queenDecisions,
-  workerPhaseOutputs,
-  -1.0  // Hyperbolic space for hierarchy
-);
-```
-
-### Worker Level (Phase Execution)
-
-```typescript
-// Phase specialists execute under queen guidance
-const workers = [
-  { agent: 'specification', role: 'requirements_analysis' },
-  { agent: 'pseudocode', role: 'algorithm_design' },
-  { agent: 'architecture', role: 'system_design' },
-  { agent: 'refinement', role: 'code_quality' }
-];
-
-// Workers coordinate through attention mechanism
-const workerConsensus = await coordinator.coordinateAgents(
-  workers.map(w => w.output),
-  'flash'  // Fast coordination for worker level
-);
-```
-
-## 🎯 MoE Expert Routing for SPARC Phases
-
-```typescript
-// Intelligent routing to phase specialists based on task characteristics
-class SPARCRouter {
-  async routeTask(task: Task) {
-    const experts = [
-      {
-        agent: 'specification',
-        expertise: ['requirements', 'constraints', 'acceptance_criteria'],
-        successRate: 0.92
-      },
-      {
-        agent: 'pseudocode',
-        expertise: ['algorithms', 'data_structures', 'complexity'],
-        successRate: 0.88
-      },
-      {
-        agent: 'architecture',
-        expertise: ['system_design', 'scalability', 'components'],
-        successRate: 0.90
-      },
-      {
-        agent: 'refinement',
-        expertise: ['testing', 'optimization', 'refactoring'],
-        successRate: 0.91
-      }
-    ];
-
-    const routing = await coordinator.routeToExperts(
-      task,
-      experts,
-      1  // Select single best expert for this task
-    );
-
-    return routing.selectedExperts[0];
-  }
-}
-```
-
-## ⚡ Cross-Phase Learning with Attention
-
-```typescript
-// Learn patterns across SPARC phases using attention
-const crossPhaseLearning = await coordinator.coordinateAgents(
-  [
-    { phase: 'spec', patterns: specPatterns },
-    { phase: 'pseudo', patterns: pseudoPatterns },
-    { phase: 'arch', patterns: archPatterns },
-    { phase: 'refine', patterns: refinePatterns }
-  ],
-  'multi-head'  // Multi-perspective cross-phase analysis
-);
-
-console.log(`Cross-phase patterns identified: ${crossPhaseLearning.consensus}`);
-
-// Apply learned patterns to improve future cycles
-const improvements = extractImprovements(crossPhaseLearning);
-```
-
-## 📊 SPARC Cycle Improvement Tracking
-
-```typescript
-// Track methodology improvement over time
-const cycleStats = await reasoningBank.getPatternStats({
-  task: 'sparc-cycle',
-  k: 20
-});
-
-console.log(`SPARC cycle success rate: ${cycleStats.successRate}%`);
-console.log(`Average quality score: ${cycleStats.avgReward}`);
-console.log(`Common optimization opportunities: ${cycleStats.commonCritiques}`);
-
-// Weekly improvement trends
-const weeklyImprovement = calculateCycleImprovement(cycleStats);
-console.log(`Methodology efficiency improved by ${weeklyImprovement}% this week`);
-```
-
-## ⚡ Performance Benefits
-
-### Before: Traditional SPARC coordination
-```typescript
-// Manual phase transitions
-// No pattern reuse across cycles
-// Sequential phase execution
-// Limited quality gate enforcement
-// Time: ~1 week per cycle
-```
-
-### After: Self-learning SPARC coordination (v2.0.0-alpha)
-```typescript
-// 1. Hierarchical coordination (queen-worker model)
-// 2. MoE routing to optimal phase specialists
-// 3. ReasoningBank learns from past cycles
-// 4. Attention-based cross-phase learning
-// 5. Parallel phase execution where possible
-// Time: ~2-3 days per cycle, Quality: +40%
-```
+This agent orchestrates the complete SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology, ensuring systematic and high-quality software development.
 
 ## SPARC Phases Overview