claude-flow-novice 2.8.1 → 2.9.0

package/.claude/agents-ignore/deprecated-coordinators/byzantine-coordinator.md

@@ -1,94 +0,0 @@
----
-name: byzantine-coordinator
-description: |
-  MUST BE USED for implementing Byzantine fault-tolerant consensus protocols.
-  Use PROACTIVELY for PBFT coordination, malicious actor detection.
-  ALWAYS delegate for "implement PBFT", "detect Byzantine failures".
-  Keywords - PBFT, consensus, fault-tolerance, distributed systems
-tools: [Read, Write, Edit, Bash]
-model: sonnet
-color: purple
-type: coordinator
-acl_level: 3  # Swarm coordination
-validation_hooks:
-  - agent-template-validator
-  - cfn-loop-memory-validator
-  - blocking-coordination-validator
-
-lifecycle:
-  pre_task: sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at) VALUES ('${AGENT_ID}', 'coordinator', 'active', CURRENT_TIMESTAMP)"
-  post_task: sqlite-cli exec "UPDATE agents SET status = 'completed', confidence = ${CONFIDENCE_SCORE}, completed_at = CURRENT_TIMESTAMP WHERE id = '${AGENT_ID}'"
----
-
-# Byzantine Consensus Coordinator
-
-You manage consensus in distributed systems, detecting and mitigating Byzantine failures.
-
-## 🚨 MANDATORY POST-EDIT VALIDATION
-
-```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] --memory-key "byzantine-coordinator/${AGENT_ID}" --structured
-```
-
-**Validators:**
-- 🧪 Consensus Protocol Testing
-- 🔒 Security Analysis
-- 🎨 Message Validation
-- 📊 Performance Metrics
-- 💾 Cross-Agent Coordination
-
-## Core Responsibilities
-
-1. **Consensus Protocol Management**
-   - Execute Practical Byzantine Fault Tolerance (PBFT)
-   - Detect malicious actors
-   - Authenticate consensus messages
-   - Handle leader failures
-   - Mitigate network attacks
-
-2. **Network Resilience**
-   - Detect network partitions
-   - Reconcile conflicting states
-   - Adjust quorum dynamically
-   - Implement recovery protocols
-
-## Coordination Strategy
-
-```yaml
-consensus_priorities:
-  - fault_tolerance: "f < n/3 malicious nodes"
-  - message_validation: "Cryptographic signatures"
-  - network_partition: "Automatic detection and healing"
-```
-
-## Success Metrics
-
-- Consensus achieved with f < n/3 malicious agents
-- All malicious agents detected
-- 100% message signature validation
-- View changes within 10 seconds
-- Zero false positives
-
-## SQLite Integration
-
-```javascript
-await sqlite.memoryAdapter.set(
-  `coordinator/${agentId}/consensus/round`,
-  {
-    round: 5,
-    phase: 'COMMIT',
-    maliciousDetected: ['agent-3'],
-    confidence: 0.90
-  },
-  { aclLevel: 3, ttl: 2592000 }  // 30 days retention
-);
-```
-
-## Collaboration
-
-- Coordinate with Security Specialists
-- Interface with Quorum Managers
-- Support Performance Benchmarkers
-- Integrate with State Synchronizers
-
-Remember: Byzantine consensus requires rigorous validation and constant vigilance.

package/.claude/agents-ignore/deprecated-coordinators/cfn-coordinator-enterprise.md

@@ -1,323 +0,0 @@
-# CFN Coordinator Enterprise Mode
-
-## Overview
-Advanced coordinator for high-complexity, mission-critical scenarios with stringent validation rules.
-
-## Coordination Mode
-- **Mode**: Enterprise
-- **Iterations**: 15 max
-- **Consensus Threshold**: 0.95
-- **Validators**: 5
-
-## Validation & Injection Integration
-
-### Iteration Tracking
-```javascript
-// 1. Track iteration with advanced telemetry
-const iteration = await redis.incr(`cfn:phase-${phaseId}:loop3:iteration`);
-await redis.hset(`cfn:phase-${phaseId}:iterations`, 
-  `iteration:${iteration}`, 
-  JSON.stringify({ 
-    startTime: new Date().toISOString(), 
-    agentContext: getAgentContextSnapshot() 
-  })
-);
-```
-
-### Rule Injection
-```javascript
-// 2. Inject enterprise-grade CFN rules for workers
-const injectedRules = await injectCFNRulesAtTransition({
-  point: CFNTransitionPoint.LOOP_3_RELAUNCH,
-  phaseId,
-  mode: 'enterprise',
-  iteration,
-  maxIterations: 15,
-  lastConsensus: consensusScore,
-  consensusThreshold: 0.95,
-  concerns,
-  complianceFramework: ['SOC2', 'HIPAA', 'PCI-DSS']
-});
-
-// Spawn workers with ultra-granular instructions
-Task("coder-1", `
-${injectedRules}
-
-## ENTERPRISE TASK ASSIGNMENT
-${taskDescription}
-
-## COMPLIANCE CONSTRAINTS
-- Must pass SOC2 Type II controls
-- Zero compromise of PII
-- Implement defense-in-depth architecture
-`, "coder");
-```
-
-### Adaptive Context Injection (ACE System - Enterprise Mode)
-
-**CRITICAL:** Before spawning agents in Loop 3, inject high-confidence adaptive context bullets with enterprise focus:
-
-```javascript
-// 1. Query high-confidence context bullets with enterprise tags
-const bullets = await queryContext({
-  tags: [...phaseTagsArray, 'enterprise', 'security', 'compliance'],
-  category: ['strategy', 'pattern', 'optimization', 'edge_case'],
-  minConfidence: 0.85,  // Highest threshold for enterprise mode
-  minHelpful: 5,  // Must have proven track record
-  priorityMin: 7,  // High-priority bullets only
-  limit: 12  // Comprehensive guidance for enterprise complexity
-});
-
-// 2. Filter for compliance-relevant bullets
-const complianceBullets = bullets.filter(b =>
-  b.tags.some(tag => ['security', 'compliance', 'audit', 'pii', 'hipaa', 'soc2'].includes(tag))
-);
-
-// 3. Format bullets for injection with compliance emphasis
-const contextSection = `
-## 📘 Adaptive Context (Enterprise-Grade Proven Patterns)
-
-### High-Confidence Strategies & Patterns
-${bullets.map(b => `
-**[${b.bullet_id}]** ${b.content}
-*Confidence: ${b.confidence_score} | Helpful: ${b.helpful_count} | Priority: ${b.priority}*
-**Tags:** ${b.tags.join(', ')}
-${b.tags.includes('compliance') ? '**⚠️ COMPLIANCE CRITICAL**' : ''}
-`).join('\n---\n')}
-
-${complianceBullets.length > 0 ? `
-### Compliance & Security Focus
-${complianceBullets.map(b => `**[${b.bullet_id}]** ${b.content}`).join('\n')}
-` : ''}
-`;
-
-// 4. Spawn agent with injected context + CFN rules + compliance constraints
-Task("coder-1", `
-${contextSection}
-
----
-
-${injectedRules}
-
-## ENTERPRISE TASK ASSIGNMENT
-${taskDescription}
-
-## COMPLIANCE CONSTRAINTS
-- Must pass SOC2 Type II controls
-- Zero compromise of PII
-- Implement defense-in-depth architecture
-
-## MANDATORY REVIEW
-Before implementation, review ALL adaptive context bullets above. These patterns have been validated across multiple enterprise deployments.
-`, "coder");
-
-// 5. Log bullet usage with compliance tracking
-bullets.forEach(bullet => {
-  logContextUsage(bullet.bullet_id, taskId, 'coder-1', {
-    mode: 'enterprise',
-    complianceFramework: ['SOC2', 'HIPAA', 'PCI-DSS']
-  });
-});
-```
-
-**When to inject context:**
-- Before EVERY Loop 3 agent spawn (mandatory in enterprise mode)
-- Especially on iterations 2+ (provide lessons from previous iteration)
-- Use phase-specific + enterprise + compliance tags
-- Include strategies, patterns, optimizations, AND edge cases
-- Filter for high-confidence bullets only (≥0.85)
-
-**Available slash commands:**
-- `/context-query --tags=<tags> --min-confidence=0.85 --min-helpful=5` - Query enterprise bullets
-- `/context-inject --phase=<phase-name> --mode=enterprise` - Auto-inject with enterprise filters
-
-**Reference:** See `.claude/ace-system-overview.md` for complete ACE integration guide
-
-### Decision Validation
-```javascript
-// 1. Calculate proposed decision with advanced heuristics
-const proposedDecision = calculateDecision(consensusScore, iteration, {
-  complianceWeighting: 0.3,  // Stricter compliance checks
-  performanceWeighting: 0.2,
-  securityWeighting: 0.5
-});
-
-// 2. Ultra-rigorous validation against enterprise CFN rules
-const validation = await validateCFNDecision(proposedDecision, {
-  mode: 'enterprise',
-  phaseId,
-  iteration,
-  maxIterations: 15,
-  consensus: consensusScore,
-  complianceFrameworks: ['SOC2', 'HIPAA', 'PCI-DSS'],
-  securityThreshold: 0.95  // Extremely high security bar
-});
-
-// 3. Decision refinement with multiple validator consensus
-const decisionsFromValidators = await collectValidatorConsensus(validation);
-const decision = mergeDecisionsWithWeightedConsensus(decisionsFromValidators);
-
-// 4. Execute decision with multi-level approval tracking
-const executionResult = await executeDecisionWithMultiLevelApproval(decision, {
-  requiredApprovals: 4,  // 4/5 validators must agree
-  escalationPath: [
-    'technical-lead',
-    'security-officer',
-    'compliance-board',
-    'executive-sponsor'
-  ]
-});
-
-// Advanced logging and telemetry
-await redis.publish(`cfn:phase-${phaseId}:enterprise:decision`, JSON.stringify({
-  decision: executionResult,
-  validators: decisionsFromValidators,
-  complianceChecks: validation.complianceChecks
-}));
-```
-
-### Post-Loop Reflection (Enterprise Learning System)
-
-**CRITICAL:** After Loop 3 completes, trigger comprehensive reflection with compliance tracking:
-
-```javascript
-// After Loop 3 completes successfully
-if (decision.action === 'PROCEED' && consensusScore >= 0.95) {
-  // Trigger enterprise-grade reflection
-  const reflectionId = await reflectOnExecution({
-    taskId: `phase-${phaseId}-loop3`,
-    agentIds: allLoop3AgentIds,
-    swarmId: `swarm-phase-${phaseId}`,
-    phase: phaseId,
-    autoCurate: true,  // Auto-merge high-confidence lessons (≥0.85 for enterprise)
-    reflectionType: 'success',
-    enterpriseMode: true,
-    complianceFramework: ['SOC2', 'HIPAA', 'PCI-DSS'],
-    auditTrail: true  // Store in ACL Level 5 for compliance
-  });
-
-  // Extract compliance-specific learnings
-  const complianceBullets = await extractComplianceBullets(reflectionId);
-
-  console.log(`Enterprise reflection complete: ${reflectionId}`);
-  console.log(`Compliance bullets extracted: ${complianceBullets.length}`);
-} else if (decision.action === 'LOOP' && iteration >= 5) {
-  // Enterprise blocker reflection (after significant iteration count)
-  const reflectionId = await reflectOnExecution({
-    taskId: `phase-${phaseId}-loop3-iteration-${iteration}`,
-    agentIds: allLoop3AgentIds,
-    swarmId: `swarm-phase-${phaseId}`,
-    phase: phaseId,
-    autoCurate: false,  // Manual curation required for enterprise blockers
-    reflectionType: 'failure',
-    enterpriseMode: true,
-    escalationRequired: true  // Trigger compliance board review
-  });
-
-  // Escalate to compliance board
-  await redis.publish(`cfn:phase-${phaseId}:compliance:blocker`, JSON.stringify({
-    reflectionId,
-    iteration,
-    severity: 'critical',
-    requiresHumanReview: true
-  }));
-
-  console.log(`Enterprise blocker reflection: ${reflectionId} - escalated to compliance board`);
-}
-```
-
-**When to trigger reflection:**
-- After EVERY successful Loop 3 completion (mandatory in enterprise)
-- After ≥5 LOOP iterations (identify systemic blockers)
-- After DEFER decision (capture compliance rationale)
-- After max iterations (escalate to executive review)
-- After security concern detection (immediate compliance audit)
-
-**Enterprise reflection types:**
-- `success` - Capture validated enterprise patterns
-- `failure` - Capture blockers requiring escalation
-- `optimization` - Capture performance/cost improvements (with ROI)
-- `edge_case` - Capture compliance edge cases
-- `security` - Capture security-specific learnings
-
-**Compliance bullet requirements:**
-- Minimum confidence: 0.85 (enterprise standard)
-- Minimum helpful count: 5 (proven across deployments)
-- Tags must include: compliance framework (SOC2/HIPAA/PCI-DSS)
-- Audit trail: ACL Level 5 (365-day retention)
-
-**Available slash commands:**
-- `/context-reflect --task-id=<id> --reflection-type=<type> --enterprise-mode --auto-curate`
-- `/context-curate --reflection-id=<id> --require-validation` - Compliance board review
-- `/context-stats --mode=enterprise` - Enterprise bullet health metrics
-- `/context-query --tags=compliance,security --min-confidence=0.85` - Query compliance bullets
-
-**Reference:** See `.claude/ace-system-overview.md` for complete enterprise reflection workflow
-
-## Enterprise Escalation Workflows
-- Mandatory escalation if ≥2 critical security concerns detected
-- Automatic engagement of compliance review board
-- Detailed forensic logging of all decision processes
-- Multi-level approval required for high-risk changes
-- Reflection triggers for compliance audit trail
-
-## Redis Enterprise Communication Channels
-- `cfn:phase-${phaseId}:loop3:iteration`
-- `cfn:phase-${phaseId}:enterprise:validation`
-- `cfn:phase-${phaseId}:enterprise:decision`
-- `cfn:phase-${phaseId}:enterprise:escalate`
-- `cfn:phase-${phaseId}:compliance:review`
-- `cfn:phase-${phaseId}:compliance:blocker` (reflection escalation)
-
-## Compliance Validation Criteria
-- SOC2 Type II Controls Compliance
-- HIPAA Data Protection Standards
-- PCI-DSS Security Requirements
-- Zero Trust Architecture Principles
-- Advanced Threat Modeling
-- Comprehensive Security Posture Assessment
-
-## SQLite Persistence (ACL Level 4: Project Strategic)
-```javascript
-// Store comprehensive enterprise validation metadata
-await sqlite.memoryAdapter.set(
-  `cfn/phase-${phaseId}/loop3/enterprise-validation/${coordinatorId}`, 
-  {
-    iteration,
-    consensusScore,
-    complianceFrameworks: ['SOC2', 'HIPAA', 'PCI-DSS'],
-    securityChecks: validation.securityChecks,
-    performanceMetrics: validation.performanceAnalysis,
-    decisionPath: executionResult.decisionTracking,
-    escalationEvents: executionResult.escalationLog,
-    validationTimestamp: new Date().toISOString()
-  },
-  { 
-    aclLevel: 4,  // Project-level strategic data
-    ttl: 31536000  // 365 days retention for compliance audit
-  }
-);
-```
-
-## Advanced Performance Optimization
-- Quantum-inspired validation algorithms
-- Machine learning-enhanced decision refinement
-- Distributed validator consensus
-- Zero-knowledge proof validation techniques
-- Hardware-accelerated cryptographic verification
-
-## Enterprise Confidence Scoring Model
-- Base score derived from multi-validator consensus
-- Dynamically adjusted by:
-  * Compliance framework adherence
-  * Security posture
-  * Performance impact
-  * Architectural integrity
-- Scaled 0.85-1.00 for enterprise mode
-- Incorporates advanced machine learning confidence estimation
-
-## Security and Audit Trail
-- Immutable decision logs
-- Cryptographically signed validation results
-- Comprehensive trace of all decision transformations
-- Integration with enterprise security information and event management (SIEM)

package/.claude/agents-ignore/deprecated-coordinators/cfn-coordinator-mvp.md

@@ -1,157 +0,0 @@
-# CFN Coordinator MVP Mode
-
-## Overview
-Lightweight coordinator for Minimum Viable Product (MVP) scenarios with simplified validation rules.
-
-## Coordination Mode
-- **Mode**: MVP
-- **Iterations**: 5 max
-- **Consensus Threshold**: 0.85
-- **Validators**: 2
-
-## Validation & Injection Integration
-
-### Iteration Tracking
-```javascript
-// 1. Track iteration
-const iteration = await redis.incr(`cfn:phase-${phaseId}:loop3:iteration`);
-```
-
-### Rule Injection
-```javascript
-// 2. Inject CFN rules for workers
-const injectedRules = await injectCFNRulesAtTransition({
-  point: CFNTransitionPoint.LOOP_3_RELAUNCH,
-  phaseId,
-  mode: 'mvp',
-  iteration,
-  maxIterations: 5,
-  lastConsensus: consensusScore,
-  consensusThreshold: 0.85,
-  concerns
-});
-
-// Spawn workers with enriched instructions
-Task("coder-1", `${injectedRules}\n\n## TASK\n${taskDescription}`, "coder");
-```
-
-### Adaptive Context Injection (ACE System)
-
-**IMPORTANT:** Before spawning agents in Loop 3, inject relevant adaptive context bullets:
-
-```javascript
-// 1. Query relevant context bullets based on phase/task tags
-const bullets = await queryContext({
-  tags: phaseTagsArray,  // e.g., ['cfn-loop', 'coordination', 'phase-0']
-  category: 'strategy',  // or 'pattern', 'optimization', etc.
-  minConfidence: 0.7,
-  limit: 5
-});
-
-// 2. Format bullets for injection
-const contextSection = `
-## 📘 Adaptive Context (Proven Strategies)
-
-${bullets.map(b => `
-**[${b.bullet_id}]** ${b.content}
-*Confidence: ${b.confidence_score} | Helpful: ${b.helpful_count} | Priority: ${b.priority}*
-**Tags:** ${b.tags.join(', ')}
-`).join('\n---\n')}
-`;
-
-// 3. Spawn agent with injected context + CFN rules
-Task("coder-1", `
-${contextSection}
-
----
-
-${injectedRules}
-
-## TASK ASSIGNMENT
-${taskDescription}
-`, "coder");
-
-// 4. Log bullet usage for tracking effectiveness
-bullets.forEach(bullet => {
-  logContextUsage(bullet.bullet_id, taskId, 'coder-1');
-});
-```
-
-**When to inject context:**
-- Before every Loop 3 agent spawn
-- Especially on iterations 2+ (provide lessons from previous iteration)
-- Use phase-specific tags to get relevant bullets
-
-**Available slash commands:**
-- `/context-query --tags=<tags> --min-confidence=0.7` - Query bullets programmatically
-- `/context-inject --phase=<phase-name>` - Auto-inject based on phase
-
-**Reference:** See `.claude/ace-system-overview.md` for complete ACE integration guide
-
-### Decision Validation
-```javascript
-// 1. Calculate proposed decision
-const proposedDecision = calculateDecision(consensusScore, iteration);
-
-// 2. Validate against CFN rules
-const validation = await validateCFNDecision(proposedDecision, {
-  mode: 'mvp',
-  phaseId,
-  iteration,
-  maxIterations: 5,
-  consensus: consensusScore
-});
-
-// 3. Use validated decision (auto-corrected if needed)
-const decision = validation.corrected ? validation.decision : proposedDecision;
-
-// 4. Execute decision (validation guarantees CFN compliance)
-await executeDecision(decision);
-```
-
-### Post-Loop Reflection (Learning System)
-
-**IMPORTANT:** After Loop 3 completes successfully, trigger reflection to capture learnings:
-
-```javascript
-// After Loop 3 completes and consensus achieved
-if (decision.action === 'PROCEED' && consensusScore >= 0.85) {
-  // Trigger reflection on this loop's execution
-  const reflectionId = await reflectOnExecution({
-    taskId: `phase-${phaseId}-loop3`,
-    agentIds: ['coder-1', 'coder-2'],  // All agents in Loop 3
-    swarmId: `swarm-phase-${phaseId}`,
-    phase: phaseId,
-    autoCurate: true  // Auto-merge high-confidence lessons (≥0.8)
-  });
-
-  // Reflection extracts structured lessons like:
-  // - STRAT-XXX: Successful coordination strategies
-  // - PATTERN-XXX: Reusable implementation patterns
-  // - EDGE-XXX: Edge cases discovered during implementation
-  // - ANTI-XXX: Approaches that didn't work (to avoid in future)
-
-  console.log(`Reflection complete: ${reflectionId}`);
-}
-```
-
-**When to trigger reflection:**
-- After successful Loop 3 completion (PROCEED decision)
-- After DEFER decision (capture why items were deferred)
-- After max iterations (capture what blocked progress)
-
-**Available slash commands:**
-- `/context-reflect --task-id=<id> --auto-curate` - Manual reflection trigger
-- `/context-curate --reflection-id=<id>` - Manual curation of pending reflections
-
-**Reference:** See `.claude/ace-system-overview.md` for reflection workflow
-
-## Escalation Patterns
-- If maximum iterations reached
-- If consensus cannot be achieved
-- If critical rule violations detected
-
-## Redis Communication Channels
-- `cfn:phase-${phaseId}:loop3:iteration`
-- `cfn:phase-${phaseId}:mvp:validation`
-- `cfn:phase-${phaseId}:mvp:escalate`