claude-flow-novice 2.18.5 → 2.18.6

package/.claude/cfn-extras/agents/deprecated-coordinators/byzantine-coordinator.md

@@ -0,0 +1,100 @@
+---
+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
+
+## Completion Protocol
+
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on work quality
+- Summary of analysis/review completed
+- List of findings or deliverables
+- Any recommendations made
+
+**Note:** Coordination instructions are provided when spawned via CLI.
+---
+
+# 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/cfn-extras/agents/deprecated-coordinators/cfn-coordinator-enterprise.md

@@ -0,0 +1,323 @@
+# 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/cfn-extras/agents/deprecated-coordinators/cfn-coordinator-mvp.md

@@ -0,0 +1,157 @@
+# 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`