claude-flow-novice 2.6.0 → 2.9.0

package/.claude/templates/post-edit-validation.md

@@ -1,109 +0,0 @@
-## Post-Edit Validation Template
-
-### Validation Hooks Framework
-
-```typescript
-interface ValidationResult {
-  valid: boolean;
-  confidence: number;
-  recommendations: string[];
-  details: {
-    fileType: string;
-    lintIssues: number;
-    testCoverage: {
-      line: number;
-      branch: number;
-      function: number;
-    }
-  }
-}
-
-class PostEditValidator {
-  async validate(file: string, content: string): Promise<ValidationResult> {
-    const validators = [
-      this.validateLinting(),
-      this.validateTestCoverage(),
-      this.validateSecurityPatterns(),
-      this.validateCodeQuality()
-    ];
-
-    const results = await Promise.all(validators);
-
-    return {
-      valid: results.every(r => r.valid),
-      confidence: this.calculateConfidence(results),
-      recommendations: results.flatMap(r => r.recommendations),
-      details: {
-        fileType: path.extname(file),
-        lintIssues: results[0].details.lintIssues,
-        testCoverage: results[1].details.coverage
-      }
-    };
-  }
-
-  private calculateConfidence(results: ValidationResult[]): number {
-    const confidenceScores = results.map(r => r.valid ? r.confidence : 0);
-    return confidenceScores.reduce((a, b) => a + b, 0) / confidenceScores.length;
-  }
-
-  // Separate validator methods implementation here
-}
-
-// Usage
-const validator = new PostEditValidator();
-const result = await validator.validate('/path/to/file.ts', fileContent);
-```
-
-### Validation Strategies
-
-1. **Linting Validation**
-   - Check code style consistency
-   - Detect potential bugs
-   - Enforce best practices
-
-2. **Test Coverage Validation**
-   - Ensure minimum coverage thresholds
-   - Validate test quality
-   - Detect untested code paths
-
-3. **Security Pattern Detection**
-   - Identify potential vulnerabilities
-   - Check for hardcoded credentials
-   - Validate input sanitization
-
-4. **Code Quality Assessment**
-   - Complexity analysis
-   - Architectural best practices
-   - Design pattern adherence
-
-### Configuration Example
-
-```yaml
-post_edit_validation:
-  linting:
-    threshold: 0.90  # 90% lint pass rate
-  test_coverage:
-    line: 0.80       # 80% line coverage
-    branch: 0.75     # 75% branch coverage
-    function: 0.85   # 85% function coverage
-  security:
-    critical_issues: 0  # No critical security issues allowed
-    high_priority_issues: 0  # No high-priority issues
-  code_quality:
-    complexity_threshold: 10  # Cyclomatic complexity limit
-```
-
-### Hooks Integration
-
-```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] \
-  --memory-key "validation/context" \
-  --structured \
-  --confidence-output
-```
-
-### Performance Metrics
-
-- Execution Time: <5s
-- False Positive Rate: <2%
-- Accuracy: >95%

package/.claude/templates/redis-coordination.md

@@ -1,140 +0,0 @@
-## Redis Coordination Template
-
-### Core Patterns
-
-#### Worker-Coordinator Signaling
-
-```bash
-# Worker signals completion
-redis-cli lpush "swarm:cfn:${mode}:loop3:worker${WORKER_ID}:done" \
-  '{"confidence":${CONFIDENCE},"mode":"${mode}"}'
-
-# Coordinator aggregates worker results
-coordinator_result=$(redis-cli blpop "swarm:cfn:${mode}:loop3:complete" 0)
-```
-
-#### Validation Broadcast
-
-```bash
-# Loop 2 Coordinator broadcasts to validators
-for i in $(seq 1 $validator_count); do
-  redis-cli lpush "swarm:cfn:${mode}:validator${i}:inbox" "$loop3_result"
-done
-```
-
-#### Mode-Specific Channels
-
-```javascript
-const redisChannels = {
-  mvp: {
-    loop3: `swarm:cfn:mvp:loop3`,
-    loop2: `swarm:cfn:mvp:loop2`
-  },
-  standard: {
-    loop3: `swarm:cfn:standard:loop3`,
-    loop2: `swarm:cfn:standard:loop2`
-  },
-  enterprise: {
-    loop3: `swarm:cfn:enterprise:loop3`,
-    loop2: `swarm:cfn:enterprise:loop2`,
-    loop2b: `swarm:cfn:enterprise:loop2b`
-  }
-};
-```
-
-### Swarm Coordination Event Publishing
-
-```javascript
-// Swarm coordination initiation
-await redis.publish('swarm:coordination:start', JSON.stringify({
-  coordinatorId: process.env.AGENT_ID,
-  swarmId: process.env.SWARM_ID,
-  mode: process.env.MODE || 'standard',
-  timestamp: new Date().toISOString()
-}));
-
-// Topology adaptation
-await redis.publish('swarm:topology:adaptation', JSON.stringify({
-  coordinatorId: process.env.AGENT_ID,
-  swarmId: process.env.SWARM_ID,
-  adaptation: {
-    from: 'current_topology',
-    to: 'target_topology',
-    confidence: 0.87,
-    timestamp: new Date().toISOString()
-  }
-}));
-```
-
-### Connection Loss Handling
-
-```typescript
-try {
-  await redis.publish('swarm:decision', JSON.stringify(decisionData));
-} catch (error) {
-  if (error.code === 'REDIS_CONNECTION_LOST') {
-    console.warn('Redis connection lost - notification skipped');
-    // Log to SQLite audit trail
-    await sqlite.query(`
-      INSERT INTO audit_log (agent_id, action, details, timestamp)
-      VALUES (?, 'redis_notification_failed', ?, datetime('now'))
-    `, [process.env.AGENT_ID, JSON.stringify({ error: error.message })]);
-  }
-}
-```
-
-### Key Coordination Principles
-
-1. Use BLPOP for destructive, guaranteed message consumption
-2. Coordinator acts as message aggregator and broadcaster
-3. Each validator receives unique message
-4. Mode-specific channel separation
-5. Timeout handling for reliability
-6. Use consistent channel naming conventions
-7. Implement retry and fallback mechanisms
-8. Add timeouts to prevent hanging subscriptions
-9. Use Redis transactions for atomic operations
-10. Keep payloads small (<64KB)
-11. Use structured JSON
-12. Minimize serialization/deserialization overhead
-
-### Error Handling
-
-```javascript
-async function publishWithFallback(channel, message) {
-  try {
-    await redis.publish(channel, message);
-  } catch (error) {
-    console.error('Redis publish failed:', error);
-    // Store event for replay
-    await sqlite.query(`
-      INSERT INTO pending_events (channel, message, created_at, retry_count)
-      VALUES (?, ?, datetime('now'), 0)
-    `, [channel, message]);
-  }
-}
-```
-
-### Authentication and Security
-
-```bash
-# Redis authentication with strong password
-redis-cli --pass "$REDIS_PASSWORD" --no-auth-warning
-```
-
-### Monitoring and Metrics
-
-```javascript
-// Track Redis coordination metrics
-await sqlite.query(`
-  INSERT INTO redis_metrics (metric_type, value, timestamp)
-  VALUES ('publish_latency', ?, datetime('now'))
-`, [publishLatency]);
-```
-
-### Reliability Considerations
-
-1. Ensure SQLite as primary record
-2. Use Redis for ephemeral, non-critical notifications
-3. Log all connection loss events
-4. Implement distributed retry mechanisms

package/.claude/templates/remaining-agent-analysis.md

@@ -1,121 +0,0 @@
-# Remaining Agent Analysis
-
-**Total Agents:** 81 actual agent files
-**Optimized (Batches 1 & 2):** 31 files
-**Remaining:** 50 files
-
----
-
-## Batch 3: High Priority (>500 lines, 9 files)
-
-**Target: Reduce from ~6,500 lines to ~1,800 lines (72% reduction)**
-
-1. `cfn-loop/cfn-coordinator-unified.md` - 974 lines
-2. `swarm/mesh-coordinator.md` - 936 lines
-3. `goal/goal-planner.md` - 832 lines
-4. `swarm/blocking-coordinator-example.md` - 776 lines
-5. `core-agents/task-coordinator.md` - 681 lines
-6. `swarm/adaptive-coordinator.md` - 660 lines
-7. `architecture/system-architect.md` - 642 lines
-8. `swarm/hierarchical-coordinator.md` - 608 lines
-9. `specialized/mobile/mobile-dev.md` - 548 lines
-
-**Categories:**
-- Coordinators (6 files): unified, mesh, blocking-example, adaptive, hierarchical, task-coordinator
-- Goal planning (1 file): goal-planner
-- Architecture (1 file): system-architect
-- Mobile (1 file): mobile-dev
-
----
-
-## Batch 4: Medium Priority (300-500 lines, 18 files)
-
-**Target: Reduce from ~7,400 lines to ~2,700 lines (64% reduction)**
-
-1. `swarm/test-coordinator.md` - 500 lines
-2. `github/github-commit-agent.md` - 490 lines
-3. `frontend/state-architect.md` - 484 lines
-4. `specialized/rust-enterprise-developer.md` - 469 lines
-5. `frontend/ui-designer.md` - 462 lines
-6. `devops/devops-engineer.md` - 453 lines (may be duplicate)
-7. `consensus/byzantine-coordinator.md` - 447 lines
-8. `development/backend/dev-backend-api.md` - 434 lines
-9. `testing/playwright-tester.md` - 414 lines
-10. `documentation/api-docs/docs-api-openapi.md` - 412 lines
-11. `security/security-specialist-existing.md` - 383 lines
-12. `consensus/consensus-builder.md` - 366 lines
-13. `core-agents/planner.md` - 351 lines
-14. `product-owner-team/product-owner-agent.md` - 328 lines
-15. `product-owner-team/accessibility-advocate-persona.md` - 320 lines
-16. `product-owner-team/power-user-persona.md` - 318 lines
-17. `testing/e2e/playwright-agent.md` - 314 lines
-18. `consensus/quorum-manager.md` - 306 lines
-
-**Categories:**
-- Testing (3 files): test-coordinator, playwright-tester, playwright-agent
-- Frontend (2 files): state-architect, ui-designer
-- Security (1 file): security-specialist-existing
-- Backend (1 file): dev-backend-api
-- DevOps (1 file): devops-engineer (check for duplicate)
-- GitHub (1 file): github-commit-agent
-- Documentation (1 file): docs-api-openapi
-- Product Owner Team (3 files): product-owner-agent, accessibility-advocate, power-user
-- Consensus (3 files): byzantine-coordinator, consensus-builder, quorum-manager
-- Core (1 file): planner
-- Rust (1 file): rust-enterprise-developer
-
----
-
-## Batch 5: Low Priority (<300 lines, ~23 files)
-
-**Estimated: ~4,500 lines → ~2,000 lines (56% reduction)**
-
-Files already below 300 lines - may only need template references added and minor cleanup.
-
-**Sample files:**
-- `specialized/rust-mvp-developer.md` - 255 lines
-- `code-booster.md` - 242 lines
-- `analysis/perf-analyzer.md` - 234 lines
-- `core-agents/coordinator-hybrid.md` - 220 lines
-- `sparc/architecture.md` - 203 lines
-- `sparc/refinement.md` - 200 lines
-- `core-agents/reviewer.md` - 185 lines
-- `core-agents/coordinator.md` - 174 lines
-- And ~15 more files
-
----
-
-## Summary Statistics
-
-### Completed (Batches 1 & 2)
-- Files: 31
-- Lines removed: ~10,716
-
-### Remaining (Batches 3-5)
-- Files: 50
-- Estimated lines: ~18,400
-- Target lines: ~6,500
-- Expected savings: ~11,900 lines (65% reduction)
-
-### Total Project
-- Total files: 81 agents
-- Starting lines: ~38,000 (estimated)
-- Target lines: ~16,200
-- Total expected savings: ~21,800 lines (57% overall reduction)
-
----
-
-## Recommended Approach for Batch 3
-
-**Spawn 3 code-booster agents in parallel:**
-
-**Agent 1: Coordinators (6 files, ~4,700 lines)**
-- cfn-coordinator-unified, mesh-coordinator, adaptive-coordinator, hierarchical-coordinator, task-coordinator, blocking-coordinator-example
-
-**Agent 2: Architecture/Planning (2 files, ~1,474 lines)**
-- system-architect, goal-planner
-
-**Agent 3: Specialized (1 file, ~548 lines)**
-- mobile-dev
-
-Expected Batch 3 total: 9 files, ~6,722 lines → ~1,800 lines (73% reduction, 4,922 lines saved)

package/.claude/templates/swarm-coordination.md

@@ -1,103 +0,0 @@
-# Swarm Coordination Templates
-
-## Initialization Strategy
-```yaml
-swarm_initialization:
-  topology:
-    2-7_agents: "mesh"
-    8+_agents: "hierarchical"
-
-  strategies:
-    - balanced (predictable workflows)
-    - adaptive (dynamic requirements)
-
-  configuration:
-    - maxAgents: match actual agent count
-    - redis_channel: unique per swarm
-    - persistence: phase-scoped
-```
-
-## Agent Spawning Protocol
-```javascript
-async function spawnSwarm(objective, agentTypes) {
-  // Single message, all agents
-  const agents = agentTypes.map(type =>
-    Task(type, `
-      - Specific deliverables
-      - Coordination requirements
-      - Self-validation (0.75+ confidence)
-      - Post-edit hook compliance
-    `, type)
-  );
-
-  // Track agents via SwarmMemory
-  const swarmState = {
-    objective,
-    agents: agents.map(a => a.id),
-    confidence: [],
-    dependencies: []
-  };
-}
-```
-
-## Progress Tracking
-```typescript
-const trackingConfig = {
-  metrics: {
-    update_frequency: '5 minutes',
-    confidence_threshold: 0.75,
-    aggregation_method: 'weighted_average'
-  },
-
-  redis_key_pattern:
-    'swarm:{swarmId}:{agentId}:{metric}',
-
-  ttl: {
-    active_phase: 3600,     // 1 hour
-    completed_phase: 86400, // 24 hours
-    archived: 604800        // 7 days
-  }
-};
-```
-
-## Consensus Validation
-```javascript
-async function validateConsensus(agents) {
-  const confidenceScores = agents.map(a => a.confidence);
-
-  return {
-    overall_confidence: weightedAverage(confidenceScores),
-    passed: confidenceScores.every(score => score >= 0.75),
-    detailed_results: confidenceScores
-  };
-}
-```
-
-## Tool Usage Guidelines
-```markdown
-### Recommended Tools
-- SlashCommand: Coordination commands
-- Bash: CLI executions
-- Task: Specialized agent spawning
-- Redis: State tracking
-- SQLite: Persistent memory
-
-### Anti-Patterns
-❌ Multiple message spawning
-❌ Generic agent roles
-❌ Vague task descriptions
-❌ Skipping post-edit hooks
-```
-
-## Quality Assurance Checklist
-```markdown
-✅ Swarm initialized
-✅ Agents spawned in single message
-✅ Specific agent instructions
-✅ Signal ACK protocol
-✅ SwarmMemory configured
-✅ Confidence tracking (≥0.75)
-✅ Consensus validation (≥0.90)
-✅ SQLite lifecycle hooks
-✅ Post-edit hooks run
-```

package/.claude/templates/team-dynamics.md

@@ -1,82 +0,0 @@
-# Team Dynamics Template
-
-## Agent Collaboration Patterns
-
-### Roles and Interactions
-
-1. **Consensus Validators**
-   - Provide feedback and recommendations
-   - Identify potential issues
-   - Maintain objective assessment
-
-2. **Implementers (Loop 3 Agents)**
-   - Address targeted concerns
-   - Implement solutions within scope
-   - Report confidence and progress
-
-3. **Coordinator**
-   - Manage overall workflow
-   - Handle agent coordination
-   - Facilitate smooth transitions
-
-4. **Product Owner**
-   - Enforce scope boundaries
-   - Make strategic decisions
-   - Manage backlog and phase progression
-
-## Communication Protocols
-
-### Interaction Guidelines
-- Always use Redis pub/sub for messaging
-- Persist critical decisions in SQLite
-- Maintain transparency through structured JSON
-- Autonomous execution without seeking permission
-
-### Decision Communication Flow
-1. Validators provide feedback
-2. Product Owner classifies concerns
-3. GOAP determines optimal action
-4. Coordinators spawn appropriate agents
-5. Implementers execute targeted work
-
-## Trust and Confidence Metrics
-
-### Validator Confidence Calculation
-- Individual validator score
-- Consensus across team
-- Addressing raised concerns
-- Implementation quality
-
-### Implementer Performance
-- Confidence score per task
-- Scope adherence
-- Solution effectiveness
-- Iteration efficiency
-
-## Conflict Resolution
-
-### Scope Disagreement Handling
-- Use GOAP cost functions
-- Penalize scope expansion
-- Defer out-of-scope items
-- Maintain clear decision rationale
-
-### Escalation Triggers
-- Persistent low consensus
-- Critical disagreements
-- Repeatedly missed objectives
-- Significant resource conflicts
-
-## Learning and Adaptation
-
-### Continuous Improvement
-- Store decision history in SQLite
-- Analyze past decision patterns
-- Refine GOAP algorithms
-- Update scope boundaries based on learnings
-
-### Performance Tracking
-- Decision optimality
-- Scope maintenance rate
-- Phase completion velocity
-- Backlog quality