claude-flow-novice 2.10.5 → 2.10.7

package/claude-assets/skills/cfn-loop-validation/README.md

@@ -0,0 +1,256 @@
+# CFN Loop Validation Skill
+
+## Overview
+Advanced validation framework for iterative development workflows with dynamic consensus calculation, multi-mode validation, and adaptive quality assurance.
+
+## Status
+**OPERATIONAL** - Agent-accessible via CLI wrapper
+
+## Dependencies
+
+### Required
+- **Node.js** >= 18.0.0 (Runtime for consensus calculator)
+- **Bash** >= 4.0 (Shell wrapper scripts)
+- **jq** (JSON parsing and processing)
+- **SQLite3** (Evidence chain persistence)
+- **bc** (Basic calculator for threshold comparisons)
+
+### Optional (for enhanced features)
+- **Redis** (For distributed validation coordination)
+  - Package: `redis-server` and `redis-cli`
+  - Purpose: Publishing validation events to swarm
+
+## Installation
+
+### Install Required Dependencies
+
+```bash
+# Check Node.js version
+node --version  # Should be >= 18.0.0
+
+# Install jq (JSON processor)
+# Ubuntu/Debian
+sudo apt-get install jq bc sqlite3
+
+# macOS
+brew install jq bc sqlite3
+
+# Windows (WSL)
+sudo apt-get install jq bc sqlite3
+```
+
+### Install Optional Dependencies
+
+```bash
+# Install Redis for distributed coordination
+# Ubuntu/Debian
+sudo apt-get install redis-server redis-tools
+
+# macOS
+brew install redis
+
+# Start Redis
+redis-server &
+```
+
+### Verify Installation
+
+```bash
+# Check Node.js
+node --version  # Should be >= 18.0.0
+
+# Check jq
+jq --version  # Should show version info
+
+# Check bc
+bc --version  # Should show version info
+
+# Check SQLite
+sqlite3 --version  # Should show version info
+
+# Check Redis (optional)
+redis-cli ping  # Should return "PONG"
+
+# Test CFN validation CLI
+./.claude/skills/cfn-loop-validation/validate-iteration.sh --help
+```
+
+## Quick Start
+
+### Validate Loop 3 Confidence Gate
+
+```bash
+# MVP mode (low threshold, fast iteration)
+./.claude/skills/cfn-loop-validation/validate-iteration.sh \
+  --mode mvp \
+  --iteration 1 \
+  --confidence 0.75 \
+  --task-id feature-auth
+
+# Standard mode (balanced quality)
+./.claude/skills/cfn-loop-validation/validate-iteration.sh \
+  --mode standard \
+  --iteration 2 \
+  --confidence 0.85 \
+  --task-id feature-auth
+
+# Enterprise mode (high quality, strict validation)
+./.claude/skills/cfn-loop-validation/validate-iteration.sh \
+  --mode enterprise \
+  --iteration 1 \
+  --confidence 0.92 \
+  --task-id compliance-system
+```
+
+### Validate Loop 2 Consensus
+
+```bash
+# Validate consensus from validator swarm
+./.claude/skills/cfn-loop-validation/validate-iteration.sh \
+  --mode standard \
+  --iteration 2 \
+  --confidence 0.85 \
+  --consensus 0.92 \
+  --task-id feature-auth \
+  --json
+```
+
+### JSON Output for Agent Parsing
+
+```bash
+# Get JSON output for programmatic use
+RESULT=$(./.claude/skills/cfn-loop-validation/validate-iteration.sh \
+  --mode standard \
+  --iteration 1 \
+  --confidence 0.85 \
+  --json)
+
+# Parse result
+echo "$RESULT" | jq -r '.passed'  # true/false
+echo "$RESULT" | jq -r '.status'  # PASS/FAIL/MAX_ITERATIONS_EXCEEDED
+```
+
+## Validation Modes
+
+| Mode | Gate Threshold | Consensus | Max Iterations | Validators |
+|------|----------------|-----------|----------------|------------|
+| **MVP** | ≥0.70 | ≥0.85 | 5 | 2 |
+| **Standard** | ≥0.80 | ≥0.90 | 10 | 4 |
+| **Enterprise** | ≥0.90 | ≥0.95 | 15 | 5-8 |
+
+### Mode Selection Guide
+
+**MVP Mode:**
+- Proof of concepts
+- Rapid prototyping
+- Learning and experimentation
+
+**Standard Mode:**
+- Production applications
+- Team collaboration
+- Quality-focused development
+
+**Enterprise Mode:**
+- Financial systems
+- Healthcare applications
+- Compliance-critical systems
+
+## Exit Codes
+
+| Code | Status | Meaning | Action |
+|------|--------|---------|--------|
+| 0 | PASS | Validation passed | Continue workflow |
+| 1 | FAIL | Score below threshold | Inject feedback, retry |
+| 2 | MAX_ITERATIONS_EXCEEDED | Too many attempts | Escalate to human |
+| 3 | Invalid arguments | Bad CLI input | Fix arguments |
+| 4 | Configuration error | Config file issue | Check config.json |
+
+## Common Issues
+
+### Issue: "jq: command not found"
+**Solution:** Install jq
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install jq
+
+# macOS
+brew install jq
+```
+
+### Issue: "bc: command not found"
+**Solution:** Install bc (basic calculator)
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install bc
+
+# macOS
+brew install bc
+```
+
+### Issue: "Config file not found"
+**Solution:** Verify config.json exists
+
+```bash
+ls -la ./.claude/skills/cfn-loop-validation/config.json
+```
+
+### Issue: "Permission denied"
+**Solution:** Make script executable
+
+```bash
+chmod +x ./.claude/skills/cfn-loop-validation/validate-iteration.sh
+```
+
+### Issue: SQLite database errors
+**Solution:** Ensure SQLite3 is installed and database directory exists
+
+```bash
+# Install SQLite3
+sudo apt-get install sqlite3  # Ubuntu/Debian
+brew install sqlite3          # macOS
+
+# Create database directory
+mkdir -p ./.claude/skills/cfn-loop-validation/
+
+# Verify database can be accessed
+sqlite3 ./.claude/skills/cfn-loop-validation/evidence-chain.db "SELECT 1;"
+```
+
+## Evidence Chain Persistence
+
+Validation results are automatically stored in SQLite for audit trails:
+
+```bash
+# Query validation history
+sqlite3 ./.claude/skills/cfn-loop-validation/evidence-chain.db \
+  "SELECT task_id, iteration, confidence, status, timestamp
+   FROM validation_evidence
+   WHERE task_id = 'feature-auth'
+   ORDER BY timestamp DESC;"
+```
+
+## Documentation
+See `SKILL.md` for comprehensive documentation including:
+- Validation workflow patterns
+- Integration with coordinator agents
+- Evidence chain schema
+- Redis integration for async validation
+- Performance targets and telemetry
+
+## Performance Targets
+- Average execution time: <500ms
+- Memory footprint: <50MB
+- Consensus accuracy: >90%
+- SQLite write latency: <20ms
+
+## Related Skills
+- **Agent Spawning** - `.claude/skills/agent-spawning/SKILL.md`
+- **Redis Coordination** - `.claude/skills/redis-coordination/SKILL.md`
+- **Hook Pipeline** - `.claude/skills/hook-pipeline/SKILL.md`
+
+---
+**Version:** 2.0.0
+**Last Updated:** 2025-10-18
+**Maintainer:** Claude Flow Novice Team

package/claude-assets/skills/cfn-loop-validation/SKILL.md

@@ -0,0 +1,353 @@
+# CFN Loop Validation Skill
+
+**Purpose:** Implement multi-layer validation and quality gates for CFN Loop workflows with clean agent exit patterns.
+
+**Version:** 2.3.0  
+**Confidence:** 0.98  
+**Status:** Production Ready (Robustness Enhanced)
+
+---
+
+## Core Architecture
+
+### Clean Agent Exit Protocol
+
+**Critical Principle:** Agents MUST exit immediately after reporting confidence. No waiting mode for implementers/validators.
+
+```bash
+# ✅ CORRECT - Agent completion protocol
+# Step 1: Complete work
+# Step 2: Signal completion
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+
+# Step 3: Report confidence
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence 0.85 \
+  --iteration 1
+
+# Step 4: EXIT CLEANLY (no waiting mode)
+# Agent process terminates here
+```
+
+```bash
+# ❌ FORBIDDEN - Agents entering waiting mode
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
+  --task-id "$TASK_ID" \
+  --agent-id "${AGENT_ID}" \
+  --context "iteration-complete"
+```
+
+**Why Clean Exit Matters:**
+- Prevents orchestrator blocking on `wait $PID`
+- Enables adaptive agent specialization (different agents per iteration)
+- Eliminates indefinite blocking scenarios
+- Supports true parallel execution
+
+### Validation Layers
+
+#### Layer 1: Gate Validation (Loop 3 Self-Validation)
+- **Threshold:** Mode-dependent (0.70-0.85)
+- **Purpose:** Implementers self-assess work quality
+- **Blocking:** Prevents validators from reviewing incomplete work
+
+#### Layer 2: Consensus Validation (Loop 2 Validators)
+- **Threshold:** Mode-dependent (0.80-0.95)
+- **Purpose:** Independent quality assessment
+- **Requirement:** Minimum 2 validators for robust consensus
+
+#### Layer 3: Product Owner Decision
+- **Purpose:** Strategic validation and scope enforcement
+- **Options:** PROCEED/ITERATE/ABORT
+- **Anti-Pattern Prevention:** Prevents "consensus on vapor"
+
+### Dependency Enforcement
+
+**Mandatory Flow:**
+1. Loop 3 agents complete work
+2. Gate check validates Loop 3 quality
+3. **IF gate passes →** Signal `swarm:${TASK_ID}:gate-passed`
+4. Loop 2 validators wait for gate signal via `blpop`
+5. Loop 2 validators review and report consensus
+6. Product Owner makes final decision
+
+**Redis Coordination:**
+```bash
+# Loop 2 agents wait for gate signal
+redis-cli blpop "swarm:${TASK_ID}:gate-passed" 0
+
+# Gate signal sent by orchestrator
+redis-cli lpush "swarm:${TASK_ID}:gate-passed" "true"
+```
+
+---
+
+## Mode Configurations
+
+### MVP Mode (Fast Validation)
+- **Gate Threshold:** 0.70
+- **Consensus Threshold:** 0.80
+- **Max Iterations:** 5
+- **Validators:** 2
+- **Use Case:** Quick prototyping, proof-of-concepts
+
+### Standard Mode (Balanced Quality)
+- **Gate Threshold:** 0.75
+- **Consensus Threshold:** 0.90
+- **Max Iterations:** 10
+- **Validators:** 3-4
+- **Use Case:** Production features, standard development
+
+### Enterprise Mode (Maximum Quality)
+- **Gate Threshold:** 0.85
+- **Consensus Threshold:** 0.95
+- **Max Iterations:** 15
+- **Validators:** 5
+- **Use Case:** Critical systems, security-sensitive features
+
+---
+
+## Agent Lifecycle Management
+
+### Coordinator Responsibilities
+- Spawn agents via CLI (cost optimization)
+- Manage Redis coordination
+- Handle iteration logic
+- Collect confidence scores
+- Enforce dependency blocking
+
+### Agent Responsibilities
+- Complete assigned work
+- Signal completion via Redis
+- Report confidence score
+- **Exit immediately (no waiting mode) - MANDATORY**
+
+### Updated Agent Completion Protocol (v2.3)
+```bash
+# ✅ NEW MANDATORY PROTOCOL - All agents MUST follow
+# Step 1: Complete work
+# Step 2: Signal completion
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+
+# Step 3: Report confidence score
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence 0.92 \
+  --iteration 1
+
+# Step 4: EXIT CLEANLY (no waiting mode - agents MUST NOT enter waiting mode)
+# Agent process terminates here - orchestrator uses wait $PID
+exit 0
+```
+
+### Clean Exit Benefits
+1. **No Blocking:** Orchestrator uses `wait $PID` successfully
+2. **Adaptive Specialization:** Different agents per iteration
+3. **Resource Efficiency:** No idle agent processes
+4. **Simplified Debugging:** Clear agent lifecycle
+5. **Prevents Orchestration Deadlock:** Eliminates indefinite agent blocking
+6. **Enables True Parallelism:** Multiple agents can complete independently
+
+### Forbidden Patterns (Critical Anti-Patterns)
+```bash
+# ❌ FORBIDDEN - Agents MUST NOT enter waiting mode
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
+  --task-id "$TASK_ID" \
+  --agent-id "${AGENT_ID}" \
+  --context "iteration-complete"
+
+# ❌ FORBIDDEN - Only coordinators use waiting mode
+if [[ "$AGENT_TYPE" != "coordinator" ]]; then
+  echo "ERROR: Non-coordinator agents cannot use waiting mode"
+  exit 1
+fi
+```
+
+---
+
+## Context Injection Patterns
+
+### Multi-Layer Context Flow
+```
+Coordinator → Redis Storage → Orchestrator → Agent Spawning → Agent Context
+```
+
+**Critical Requirement:** Context must flow through ALL layers.
+
+#### Context Components
+- **Epic Context:** High-level goals and scope
+- **Phase Context:** Sprint-specific requirements
+- **Success Criteria:** Acceptance criteria and deliverables
+- **Thresholds:** Gate and consensus values
+
+#### Context Validation
+1. **Coordinator:** Validates context has deliverables before spawning
+2. **Orchestrator:** Validates Redis retrieval before agent spawning
+3. **Agents:** Validate received context has required fields
+
+**Anti-Pattern Prevention:** Avoid generic context when specifics exist in Redis.
+
+---
+
+## Quality Gates Implementation
+
+### Deliverable Verification (STRAT-020)
+**Mandatory check:** Validate actual file creation for implementation tasks.
+
+```bash
+# Check for deliverable creation
+git_status=$(git status --porcelain 2>/dev/null || echo "")
+if [[ -z "$git_status" ]] && [[ "$task_type" == "implementation" ]]; then
+    # Force iteration - no files created
+    consensus=0.0
+    feedback="No deliverable files created. Must implement actual changes."
+fi
+```
+
+### Confidence Scoring Patterns
+- **Explicit Numeric:** `0.85` (preferred)
+- **Percentage:** `85%` (supported)
+- **Qualitative:** `high/medium/low` (converted to 0.8/0.5/0.2)
+- **Calculated:** Based on deliverable completion
+
+### Multi-Pattern Parsing (PATTERN-009)
+```bash
+# Extract confidence with fallback strategies
+confidence=$(echo "$output" | grep -o "confidence: [0-9.]*" | tail -1 | cut -d' ' -f2)
+if [[ -z "$confidence" ]]; then
+    confidence=$(echo "$output" | grep -o "[0-9]*%" | tail -1 | sed 's/%//')
+    if [[ -n "$confidence" ]]; then
+        confidence=$(echo "scale=2; $confidence/100" | bc -l)
+    fi
+fi
+```
+
+---
+
+## Testing and Validation
+
+### Test Suite Requirements
+- Validate clean agent exit
+- Test dependency enforcement
+- Verify context injection
+- Check timeout handling
+- Validate consensus calculations
+
+### Key Test Cases
+1. **Clean Exit Test:** Agents exit without waiting mode
+2. **Blocking Test:** Loop 2 waits for Loop 3 gate signal
+3. **Context Test:** Deliverables flow through all layers
+4. **Iteration Test:** Quality gate triggers iteration
+5. **Timeout Test:** Agents respect phase timeouts
+
+---
+
+## Integration Points
+
+### Redis Coordination Skill
+- Uses `invoke-waiting-mode.sh report` for confidence reporting
+- No `enter` calls for implementers/validators
+- Blocking via `blpop` for dependency enforcement
+
+### Agent Spawning Skill
+- CLI spawning for cost optimization
+- Agent ID assignment and tracking
+- Background process management
+
+### Product Owner Decision Skill
+- Structured decision parsing
+- Deliverable validation
+- Scope enforcement
+
+---
+
+## Error Handling and Recovery
+
+### Timeout Scenarios
+- **Phase-specific timeouts:** Based on work complexity
+- **Agent timeout:** `timeout` command wrapper
+- **Orchestrator timeout:** Background execution with monitoring
+
+### Failure Recovery
+- **Redis state cleanup:** Clear iteration data
+- **Agent PID tracking:** Monitor and cleanup stuck processes
+- **Context validation:** Fail-fast on missing context
+
+---
+
+## Performance Optimization
+
+### Cost Savings
+- **CLI Spawning:** 95-98% cost reduction vs Task()
+- **Zero-Token Waiting:** Redis BLPOP for coordination
+- **Parallel Execution:** Background agent spawning
+
+### Resource Management
+- **Clean Exit:** No idle agent processes
+- **Timeout Enforcement:** Prevent resource leaks
+- **Redis Cleanup:** Automatic state management
+
+---
+
+## Usage Examples
+
+### Standard CFN Loop Execution
+```bash
+./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
+  --task-id "feature-auth-123" \
+  --mode standard \
+  --loop3-agents "backend-dev,security-specialist" \
+  --loop2-agents "reviewer,tester,architect" \
+  --product-owner "product-owner" \
+  --phase-id "phase-2" \
+  --epic-context '{"epicGoal":"Build auth system","inScope":["JWT","OAuth"]}' \
+  --phase-context '{"deliverables":["auth.js","tests/auth.test.js"]}' \
+  --success-criteria '{"acceptanceCriteria":["JWT tokens work","Tests pass"]}'
+```
+
+### Agent Implementation Protocol
+```bash
+# Agent receives task context
+# Completes implementation work
+
+# Signal completion
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+
+# Report confidence
+./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence 0.92 \
+  --iteration 1
+
+# EXIT CLEANLY - no waiting mode
+```
+
+---
+
+## Monitoring and Debugging
+
+### Key Redis Keys
+- `swarm:${TASK_ID}:${AGENT_ID}:done` - Completion signal
+- `swarm:${TASK_ID}:${AGENT_ID}:confidence` - Confidence score
+- `swarm:${TASK_ID}:gate-passed` - Gate signal
+- `swarm:${TASK_ID}:epic-context` - Epic context
+- `swarm:${TASK_ID}:success-criteria` - Acceptance criteria
+
+### Debug Commands
+```bash
+# Check agent completion
+redis-cli lrange "swarm:${TASK_ID}:${AGENT_ID}:done" 0 -1
+
+# Check confidence scores
+redis-cli get "swarm:${TASK_ID}:${AGENT_ID}:confidence"
+
+# Monitor gate signals
+redis-cli blpop "swarm:${TASK_ID}:gate-passed" 1
+```
+
+---
+
+**Maintenance:** Regular validation of clean exit patterns and dependency enforcement. Test suite should validate all lifecycle scenarios.

package/claude-assets/skills/cfn-loop-validation/check-dependencies.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Dependency checker for CFN Loop Validation
+
+check_command() {
+  if command -v "$1" &> /dev/null; then
+    VERSION=$($1 --version 2>&1 | head -n1)
+    echo "✅ $1: $VERSION"
+    return 0
+  else
+    echo "❌ $1: NOT FOUND"
+    return 1
+  fi
+}
+
+echo "Checking dependencies for CFN Loop Validation..."
+MISSING=0
+
+# Required dependencies
+check_command "bash" || MISSING=$((MISSING+1))
+check_command "jq" || MISSING=$((MISSING+1))
+check_command "bc" || MISSING=$((MISSING+1))
+
+if [ $MISSING -eq 0 ]; then
+  echo ""
+  echo "✅ All required dependencies installed"
+  exit 0
+else
+  echo ""
+  echo "❌ Missing $MISSING required dependencies"
+  exit 1
+fi