claude-flow-novice 2.6.0 → 2.8.1

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

@@ -1,263 +1,353 @@
----
-name: CFN Loop Validation
-version: 2.2.0
-complexity: High
-status: OPERATIONAL
-keywords: [
-    "consensus-driven",
-    "validation framework",
-    "adaptive thresholds",
-    "quality assurance",
-    "multi-mode validation",
-    "agent-accessible",
-    "CLI wrapper",
-    "claim validation"
-]
-triggers: [
-    "complex system architecture validation",
-    "iterative quality assessment",
-    "multi-phase validation",
-    "feedback cycles",
-    "improvement cycles",
-    "CFN loop iteration validation",
-    "claim-based verification"
-]
-performance_targets: {
-    "consensus_accuracy": 90,
-    "validation_speed_ms": 1000,
-    "max_parallel_validators": 15,
-    "resource_utilization_pct": 50,
-    "claim_validation_threshold": 0.8
-}
----
 # CFN Loop Validation Skill
-## Overview
-Advanced validation framework for iterative development workflows, enabling dynamic consensus calculation, multi-mode validation, and adaptive quality assurance across complex system development. Now with claim validation support in agent-accessible CLI wrapper.
-## Status: OPERATIONAL
-The CFN Loop Validation skill is fully operational with the following components:
-- CLI Wrapper: `/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-loop-validation/validate-iteration.sh`
-- Configuration: `/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-loop-validation/config.json`
-- Consensus Calculator: `/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-loop-validation/consensus-calculator.js`
-- Evidence Database: `/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-loop-validation/evidence-chain.sql`
+
+**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)
+
 ---
-# [Rest of previous SKILL.md content remains the same, with following updates]
 
-## 10. CFN Loop Orchestration (NEW in v2.2.0)
+## Core Architecture
 
-### Orchestration Script
-The CFN Loop skill now includes **automatic dependency orchestration** via `orchestrate-cfn-loop.sh`.
+### Clean Agent Exit Protocol
 
-**Purpose:** Ensures agents complete work in the correct order with BLPOP-based dependency enforcement.
+**Critical Principle:** Agents MUST exit immediately after reporting confidence. No waiting mode for implementers/validators.
 
-### Loop Structure
-```
-Loop 3 (Primary Swarm - Implementers)
-  ↓ [BLPOP blocks until all Loop 3 agents signal :done]
-Loop 2 (Consensus - Validators)
-  ↓ [BLPOP blocks until all Loop 2 agents signal :done]
-Product Owner (GOAP Decision)
-  ↓ Decision: PROCEED | RELAUNCH iteration N+1
+```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
 ```
 
-### Dependency Enforcement (CORRECTED - Self-Validation Pattern)
 ```bash
-# 1. Loop 3 agents complete and self-validate
-for agent in loop3-agents; do
-  redis-cli blpop "swarm:${TASK_ID}:${agent}:done" 0
-done
-
-# 2. Gate check on Loop 3 self-validation
-if gate_passed; then
-  # Signal Loop 2 validators to start
-  redis-cli lpush "swarm:${TASK_ID}:gate-passed" "{\"loop3_confidence\": $CONFIDENCE}"
-else
-  # Relaunch Loop 3 for iteration N+1 (skip Loop 2)
-  wake_loop3_agents
-  continue
-fi
+# ❌ 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"
+```
 
-# 3. Loop 2 agents WAIT for gate pass signal
-# (Each validator blocks until gate passes)
-redis-cli blpop "swarm:${TASK_ID}:gate-passed" 0
+**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
 
-# 4. Loop 2 agents complete validation
-for validator in loop2-agents; do
-  redis-cli blpop "swarm:${TASK_ID}:${validator}:done" 0
-done
+### Validation Layers
 
-# 5. Product Owner makes decision based on Loop 2 consensus
-```
+#### 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"
 
-### Usage
+### 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
-./orchestrate-cfn-loop.sh \
-  --task-id "sprint1-feature-x" \
-  --mode standard \
-  --loop3-agents "researcher,backend-dev,devops" \
-  --loop2-agents "reviewer,architect,tester" \
-  --product-owner "product-owner" \
-  --max-iterations 10
+# 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"
 ```
 
-### Agent Requirements
-Each agent MUST signal completion:
+---
+
+## 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
-# After completing work, agent signals done
+# ✅ 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"
 
-# Then report confidence
+# Step 3: Report confidence score
 ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
   --task-id "$TASK_ID" \
   --agent-id "$AGENT_ID" \
-  --confidence 0.85
+  --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
+```
 
-# Then enter waiting mode for next iteration
+### 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" \
+  --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
 ```
 
-### Benefits
-- ✅ **Automatic dependency blocking** - No manual coordination needed
-- ✅ **Zero-token waiting** - Agents blocked via BLPOP (no API calls)
-- ✅ **Consistent enforcement** - Same pattern across all CFN loops
-- ✅ **Product Owner protection** - Cannot collect before validators finish
-- ✅ **Iteration management** - Automatic wake-up for next iteration
-
-## 11. Version History
-### v2.2.0 (2025-10-18)
-- **NEW:** Added `orchestrate-cfn-loop.sh` for dependency orchestration
-- Automatic BLPOP-based dependency blocking between loops
-- Product Owner integration with consensus-ready signals
-- Iteration management with automatic wake-up
-- Prevents premature consensus collection
-### v2.1.0 (2025-10-18)
-- Added claim-based validation support
-- New `--claims` CLI flag for JSON claim validation
-- Claim confidence scoring
-- Detailed claim validation metrics
-- Support for legacy system claim integration
-### v2.0.0 (2025-10-18)
-- Added agent-accessible CLI wrapper (`validate-iteration.sh`)
-- Updated configuration with TypeScript alignment
-- Comprehensive documentation for integration patterns
-- Evidence chain persistence
-- JSON output mode for agent consumption
-### v1.0.5 (Previous)
-- Basic validation framework
-- Consensus calculator
-- Evidence database schema
-
-## 11. Agent Completion Protocol (STRAT-003)
-
-**Pattern:** Explicit multi-step process for agent task completion in CFN Loops.
-
-When building agent completion protocols, design explicit multi-step processes that include work completion, status signaling, confidence reporting, and explicit waiting modes. This prevents race conditions and ensures proper dependency blocking.
-
-### 4-Step Completion Protocol
+**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
-# Step 1: Complete work
-# Agent performs implementation/validation tasks
+# 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
+```
 
-# Step 2: Signal completion
+### 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"
 
-# Step 3: Report confidence
+# Report confidence
 ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
   --task-id "$TASK_ID" \
   --agent-id "$AGENT_ID" \
-  --confidence 0.85 \
+  --confidence 0.92 \
   --iteration 1
 
-# Step 4: Enter waiting mode
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
+# EXIT CLEANLY - no waiting mode
 ```
 
-### Benefits
-- **Race condition prevention**: Explicit signaling prevents premature collection
-- **Clear state transitions**: Each step has observable state in Redis
-- **Confidence tracking**: Separate confidence reporting for gate checks
-- **Iteration support**: Agents can be woken for retry without respawning
-
-### Integration with Orchestration
-The orchestrator (`.claude/skills/redis-coordination/orchestrate-cfn-loop.sh`) enforces this protocol by:
-1. BLPOP blocking on `:done` signals (Step 2)
-2. Collecting confidence scores (Step 3)
-3. Waking agents for next iteration if needed (Step 4)
-
-## 12. Claim Validation
-### Claim Validation Overview
-Claim-based validation enables granular assessment of iteration results through explicit claim confidence scoring.
-
-#### Claim Structure
-```json
-{
-  "id": "claim_001",
-  "description": "Authentication flow meets OAUTH2 standards",
-  "confidence": 0.85,
-  "strategy": "oauth_standard_check"
-}
-```
+---
+
+## 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
 
-### Claim Validation CLI Usage
+### Debug Commands
 ```bash
-# Validate with claims
-./validate-iteration.sh \
-  --mode enterprise \
-  --iteration 1 \
-  --confidence 0.88 \
-  --claims '[
-    {
-      "id": "auth_security",
-      "description": "Secure authentication flow",
-      "confidence": 0.90
-    },
-    {
-      "id": "oauth_compliance",
-      "description": "OAUTH2 compliance",
-      "confidence": 0.75
-    }
-  ]'
-```
+# 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"
 
-### Claim Validation Result Example
-```json
-{
-  "claims": {
-    "total_count": 2,
-    "valid_count": 1,
-    "invalid_count": 1,
-    "confidence": 0.5,
-    "details": [
-      {
-        "id": "auth_security",
-        "description": "Secure authentication flow",
-        "confidence": 0.90,
-        "valid": true
-      },
-      {
-        "id": "oauth_compliance",
-        "description": "OAUTH2 compliance",
-        "confidence": 0.75,
-        "valid": false
-      }
-    ]
-  }
-}
+# Monitor gate signals
+redis-cli blpop "swarm:${TASK_ID}:gate-passed" 1
 ```
 
-### Claim Validation Metrics
-- **Confidence Threshold:** 0.8 (configurable)
-- **Metrics Captured:**
-  - Total claims
-  - Valid claims
-  - Invalid claims
-  - Overall claim confidence
-  - Detailed claim validation
+---
 
-[Rest of the previous SKILL.md remains unchanged]
+**Maintenance:** Regular validation of clean exit patterns and dependency enforcement. Test suite should validate all lifecycle scenarios.

package/.claude/skills/complexity-estimator/SKILL.md

@@ -0,0 +1,96 @@
+# Task Complexity Estimator
+
+**Version:** 1.0.0
+**Purpose:** Estimate task complexity and predict iteration requirements for CFN v3
+
+## Overview
+
+Analyzes task description to estimate:
+- Complexity level (low, medium, high)
+- Estimated iterations (2-7 range)
+- Confidence in estimate
+
+## Complexity Factors
+
+### Factor 1: Step Count
+- Count distinct action verbs
+- Count deliverable files mentioned
+- Count integration points
+
+### Factor 2: Security/Compliance
+- Security keywords → +1 complexity
+- Compliance requirements → +1 complexity
+- Authentication/authorization → +1 complexity
+
+### Factor 3: Scope
+- Single file → low
+- Multiple files (2-5) → medium
+- System-wide (>5 files) → high
+
+### Factor 4: Dependencies
+- External APIs → +1 complexity
+- Database changes → +1 complexity
+- Multiple services → +1 complexity
+
+### Factor 5: Technology Stack
+- Familiar tech → -1 complexity
+- New/unfamiliar tech → +1 complexity
+- Cutting-edge/experimental → +2 complexity
+
+## Estimation Formula
+
+```
+Base Iterations = 2
+
++ Step Count / 3
++ Security factor (0-2)
++ Scope factor (0-3)
++ Dependencies factor (0-3)
++ Tech stack factor (-1 to +2)
+
+Capped at: 7 iterations (high complexity max)
+```
+
+## Complexity Mapping
+
+| Total Score | Complexity | Estimated Iterations |
+|-------------|------------|---------------------|
+| 0-2 | Low | 2 |
+| 3-4 | Medium | 3-4 |
+| 5+ | High | 5-7 |
+
+## Usage
+
+```bash
+ESTIMATE=$(./.claude/skills/complexity-estimator/estimate-complexity.sh \
+  --task-type "software-development" \
+  --description "Implement JWT authentication with refresh tokens and RBAC")
+
+echo "$ESTIMATE" | jq '.complexity'           # "high"
+echo "$ESTIMATE" | jq '.estimated_iterations' # 5
+echo "$ESTIMATE" | jq '.confidence'           # 0.75
+```
+
+## Output Format
+
+```json
+{
+  "complexity": "low|medium|high",
+  "estimated_iterations": 2-7,
+  "confidence": 0.0-1.0,
+  "factors": {
+    "step_count": 2,
+    "security": 1,
+    "scope": 2,
+    "dependencies": 1,
+    "tech_stack": 0
+  },
+  "reasoning": "High complexity due to security requirements (JWT, RBAC), multiple integration points, and estimated 6+ file changes."
+}
+```
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Set max_iterations, estimated_iterations
+- Playbook system - Store complexity patterns