claude-flow-novice 2.14.7 → 2.14.9

package/.claude/commands/cfn-loop-cli.md

@@ -149,7 +149,7 @@ Task("cfn-v3-coordinator", `
 
   1. INVOKE ORCHESTRATOR (CLI spawning):
 
-     TASK_ID="cfn-cli-$(date +%s)"
+     TASK_ID="cfn-cli-$(date +%s%N | tail -c 7)-${RANDOM}"
      MODE="${mode}"
      LOOP3_AGENTS="backend-dev,researcher,devops"  # Customize for task
      LOOP2_AGENTS="reviewer,tester,architect,security-specialist"  # Scale by complexity

package/.claude/skills/cfn-agent-selector/SKILL.md

@@ -17,7 +17,7 @@ AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
   --task-type "software-development" \
   --description "Implement JWT authentication with refresh tokens")
 
-echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-developer", "security-specialist"]
 echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
 ```
 
@@ -35,7 +35,7 @@ echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
 ## Agent Selection Rules
 
 ### Software Development
-**Base Loop 3:** backend-dev, coder
+**Base Loop 3:** backend-developer, coder
 **Add if keywords:**
 - "security", "authentication", "JWT" → security-specialist
 - "database", "SQL", "schema" → database-engineer (if exists)

package/.claude/skills/cfn-agent-selector/SKILL.md.backup_before_replace

@@ -0,0 +1,91 @@
+# Agent Selector Skill
+
+**Version:** 1.0.0
+**Purpose:** Select optimal agents for CFN Loop v3 based on task type and requirements
+
+## Overview
+
+Recommends Loop 3 (producers) and Loop 2 (evaluators) agents based on:
+- Task type (from task-classifier)
+- Task description keywords
+- Complexity requirements
+
+## Usage
+
+```bash
+AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
+  --task-type "software-development" \
+  --description "Implement JWT authentication with refresh tokens")
+
+echo "$AGENTS" | jq '.loop3[]'  # ["backend-dev", "security-specialist"]
+echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
+```
+
+## Output Format
+
+```json
+{
+  "loop3": ["agent1", "agent2", "agent3"],
+  "loop2": ["validator1", "validator2", "validator3"],
+  "loop4": "product-owner",
+  "reasoning": "Explanation of agent selection"
+}
+```
+
+## Agent Selection Rules
+
+### Software Development
+**Base Loop 3:** backend-dev, coder
+**Add if keywords:**
+- "security", "authentication", "JWT" → security-specialist
+- "database", "SQL", "schema" → database-engineer (if exists)
+- "deploy", "CI/CD", "infrastructure" → devops-engineer
+- "frontend", "React", "UI" → react-frontend-engineer
+
+**Loop 2:** reviewer, tester, security-auditor
+
+### Content Creation
+**Base Loop 3:** copywriter, content-strategist
+**Add if keywords:**
+- "SEO", "search", "keywords" → seo-specialist
+- "technical", "documentation" → technical-writer (if exists)
+
+**Loop 2:** editor, brand-reviewer, compliance-checker
+
+### Research
+**Base Loop 3:** researcher, data-analyst
+**Add if keywords:**
+- "statistics", "data analysis" → statistician (if exists)
+- "domain-specific" → domain-expert
+
+**Loop 2:** fact-checker, methodology-reviewer, statistician
+
+### Design
+**Base Loop 3:** ui-designer, ux-researcher
+**Add if keywords:**
+- "visual", "branding" → visual-designer
+- "accessibility" → accessibility-advocate
+
+**Loop 2:** accessibility-advocate, design-critic, user-tester
+
+### Infrastructure
+**Base Loop 3:** devops-engineer, terraform-engineer
+**Add if keywords:**
+- "Kubernetes", "k8s", "container" → kubernetes-architect
+- "network", "security" → network-engineer (if exists)
+
+**Loop 2:** security-auditor, cost-optimizer, compliance-checker
+
+### Data Engineering
+**Base Loop 3:** data-engineer, pipeline-builder
+**Add if keywords:**
+- "ETL", "transformation" → etl-specialist
+- "streaming", "real-time" → streaming-specialist (if exists)
+
+**Loop 2:** data-quality-validator, schema-reviewer, performance-tester
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Agent selection
+- `.claude/skills/cfn-agent-selector/select-agents.sh` - Primary selection script

package/.claude/skills/cfn-loop-orchestration/orchestrate.sh

@@ -66,6 +66,19 @@ LOOP3_FINAL_CONFIDENCE=0.0
 LOOP2_FINAL_CONSENSUS=0.0
 DELIVERABLES_VERIFIED=false
 
+# Cleanup Redis keys before exit
+cleanup_redis_keys() {
+  if [ -n "$TASK_ID" ]; then
+    echo "🧹 Cleaning up Redis keys for task $TASK_ID"
+    # Set TTL on remaining task keys (1 hour)
+    redis-cli keys "swarm:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+    redis-cli keys "cfn_loop:task:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+  fi
+}
+
+# Trap cleanup on script exit
+trap cleanup_redis_keys EXIT
+
 ##############################################################################
 # Argument Parsing
 ##############################################################################
@@ -878,6 +891,19 @@ EOF
   esac
 done
 
+# Cleanup Redis keys before exit
+cleanup_redis_keys() {
+  if [ -n "$TASK_ID" ]; then
+    echo "🧹 Cleaning up Redis keys for task $TASK_ID"
+    # Set TTL on remaining task keys (1 hour)
+    redis-cli keys "swarm:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+    redis-cli keys "cfn_loop:task:${TASK_ID}:*" 2>/dev/null | xargs -I {} redis-cli expire {} 3600 2>/dev/null || true
+  fi
+}
+
+# Trap cleanup on script exit
+trap cleanup_redis_keys EXIT
+
 # Max iterations reached without success
 echo "❌ Max iterations ($MAX_ITERATIONS) reached without PROCEED decision"
 output_result "failed"

package/.claude/skills/cfn-product-owner-decision/execute-decision.sh

@@ -124,24 +124,34 @@ if [ $PO_EXIT_CODE -eq 124 ]; then
   CONFIDENCE=0.0
 else
   # Parse decision from output
-  PO_OUTPUT=$(cat "$PO_OUTPUT_FILE")
+  # Defensive file handling - TEST 5 fix
+  if [ -f "$PO_OUTPUT_FILE" ] && [ -s "$PO_OUTPUT_FILE" ]; then
+    PO_OUTPUT=$(cat "$PO_OUTPUT_FILE")
 
-  # Try multiple parsing patterns
-  DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oiE "Decision:\s*(PROCEED|ITERATE|ABORT)" | grep -oiE "(PROCEED|ITERATE|ABORT)" | head -1 | tr '[:lower:]' '[:upper:]' || echo "")
+    # Try multiple parsing patterns
+    DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oiE "Decision:\s*(PROCEED|ITERATE|ABORT)" | grep -oiE "(PROCEED|ITERATE|ABORT)" | head -1 | tr '[:lower:]' '[:upper:]' || echo "")
 
-  if [ -z "$DECISION_TYPE" ]; then
-    DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oE "(PROCEED|ITERATE|ABORT)" | head -1 || echo "")
-  fi
-
-  if [ -z "$DECISION_TYPE" ]; then
-    DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oiE "(proceed|iterate|abort)" | head -1 | tr '[:lower:]' '[:upper:]' || echo "")
-  fi
+    if [ -z "$DECISION_TYPE" ]; then
+      DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oE "(PROCEED|ITERATE|ABORT)" | head -1 || echo "")
+    fi
 
-  # Parse reasoning
-  REASONING=$(echo "$PO_OUTPUT" | grep -oiE "Reasoning:\s*.*" | sed 's/Reasoning:\s*//' || echo "No reasoning provided")
+    if [ -z "$DECISION_TYPE" ]; then
+      DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oiE "(proceed|iterate|abort)" | head -1 | tr '[:lower:]' '[:upper:]' || echo "")
+    fi
 
-  # Parse confidence
-  CONFIDENCE=$(echo "$PO_OUTPUT" | grep -oE "Confidence:\s*[0-9]+\.?[0-9]*" | grep -oE "[0-9]+\.?[0-9]*" || echo "0.85")
+    # Parse reasoning
+    REASONING=$(echo "$PO_OUTPUT" | grep -oiE "Reasoning:\s*.*" | sed 's/Reasoning:\s*//' || echo "No reasoning provided")
+
+    # Parse confidence
+    CONFIDENCE=$(echo "$PO_OUTPUT" | grep -oE "Confidence:\s*[0-9]+\.?[0-9]*" | grep -oE "[0-9]+\.?[0-9]*" || echo "0.85")
+  else
+    echo -e "${RED}❌ ERROR: Product Owner output file missing or empty${NC}"
+    echo "Expected: $PO_OUTPUT_FILE"
+    PO_OUTPUT=""
+    DECISION_TYPE="ABORT"
+    REASONING="Product Owner output file missing or empty: $PO_OUTPUT_FILE"
+    CONFIDENCE=0.0
+  fi
 fi
 
 # Validate decision parsing
@@ -187,6 +197,63 @@ Next iteration MUST create actual deliverables, not just plans.
   fi
 fi
 
+# Process deferred items for backlog
+echo -e "${YELLOW}📋 Processing deferred items for backlog...${NC}"
+
+# Extract deferred items from Product Owner output
+# Look for sections: "Out of Scope", "Deferred", "Future Work", "Defer"
+DEFERRED_SECTION=$(echo "$PO_OUTPUT" | grep -iA 20 "out of scope\|deferred\|future work\|defer:" || echo "")
+
+if [ -n "$DEFERRED_SECTION" ]; then
+  echo -e "${YELLOW}Found deferred items section, extracting items...${NC}"
+
+  # Parse deferred items (lines starting with -, *, or bullet points after marker)
+  DEFERRED_ITEMS=$(echo "$DEFERRED_SECTION" | grep -E "^\s*[-*•]" | sed 's/^\s*[-*•]\s*//' || echo "")
+
+  if [ -n "$DEFERRED_ITEMS" ]; then
+    ITEMS_ADDED=0
+
+    # Process each deferred item
+    while IFS= read -r item; do
+      # Skip empty lines or section headers
+      if [ -n "$item" ] && ! echo "$item" | grep -iqE "^(out of scope|deferred|future work)" && [ ${#item} -ge 10 ]; then
+        echo -e "${YELLOW}  Adding to backlog: ${item:0:60}...${NC}"
+
+        # Invoke backlog skill (defensive - don't fail decision on backlog error)
+        set +e
+        /mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-backlog-management/add-backlog-item.sh \
+          --item "$item" \
+          --why "Deferred during Product Owner decision (Task: $TASK_ID, Iteration: $ITERATION)" \
+          --solution "To be determined during sprint planning" \
+          --priority "P2" \
+          --category "Technical-Debt" \
+          --sprint "Sprint-Backlog-$ITERATION" \
+          --force >/dev/null 2>&1
+
+        if [ $? -eq 0 ]; then
+          ITEMS_ADDED=$((ITEMS_ADDED + 1))
+        else
+          echo -e "${YELLOW}  Warning: Failed to add backlog item (non-critical)${NC}" >&2
+        fi
+        set -e
+      fi
+    done <<< "$DEFERRED_ITEMS"
+
+    if [ $ITEMS_ADDED -gt 0 ]; then
+      echo -e "${GREEN}✅ Backlog updated with $ITEMS_ADDED deferred item(s)${NC}"
+
+      # Store backlog metadata in Redis
+      redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "backlog_items_added" "$ITEMS_ADDED"
+    else
+      echo -e "${YELLOW}⚠️  No valid backlog items extracted${NC}"
+    fi
+  else
+    echo -e "${YELLOW}⚠️  Deferred section found but no items extracted${NC}"
+  fi
+else
+  echo -e "${GREEN}No deferred items detected in Product Owner output${NC}"
+fi
+
 # Build decision JSON
 DECISION_JSON=$(cat <<EOF
 {

package/.claude/skills/cfn-product-owner-decision/test-backlog-integration.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+# Test script for backlog integration in execute-decision.sh
+# Version: 1.0.0
+# Purpose: Verify deferred items are correctly extracted and added to backlog
+
+set -euo pipefail
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+echo -e "${GREEN}🧪 Testing Backlog Integration in execute-decision.sh${NC}"
+
+# Create mock Product Owner output with deferred items
+MOCK_PO_OUTPUT=$(cat <<'EOF'
+Decision: PROCEED
+Reasoning: All acceptance criteria met, but some items deferred for future sprints.
+
+Out of Scope:
+- Advanced logging with structured JSON format
+- Performance monitoring dashboard
+- Integration with external analytics platform
+- Custom alert webhooks for critical events
+
+Confidence: 0.92
+EOF
+)
+
+# Test 1: Extract deferred section
+echo -e "${YELLOW}Test 1: Extracting deferred section...${NC}"
+DEFERRED_SECTION=$(echo "$MOCK_PO_OUTPUT" | grep -iA 20 "out of scope|deferred|future work|defer:" || echo "")
+
+if [ -n "$DEFERRED_SECTION" ]; then
+  echo -e "${GREEN}✅ Deferred section extracted${NC}"
+  echo "Preview:"
+  echo "$DEFERRED_SECTION" | head -5
+else
+  echo -e "${RED}❌ Failed to extract deferred section${NC}"
+  exit 1
+fi
+
+# Test 2: Parse individual items
+echo -e "\n${YELLOW}Test 2: Parsing individual items...${NC}"
+DEFERRED_ITEMS=$(echo "$DEFERRED_SECTION" | grep -E "^\s*[-*•]" | sed 's/^\s*[-*•]\s*//' || echo "")
+
+if [ -n "$DEFERRED_ITEMS" ]; then
+  ITEM_COUNT=$(echo "$DEFERRED_ITEMS" | wc -l)
+  echo -e "${GREEN}✅ Extracted $ITEM_COUNT deferred items${NC}"
+  echo "Items:"
+  echo "$DEFERRED_ITEMS" | nl
+else
+  echo -e "${RED}❌ Failed to parse individual items${NC}"
+  exit 1
+fi
+
+# Test 3: Validate item filtering
+echo -e "\n${YELLOW}Test 3: Validating item filtering...${NC}"
+VALID_ITEMS=0
+
+while IFS= read -r item; do
+  # Skip empty lines or section headers
+  if [ -n "$item" ] && ! echo "$item" | grep -iqE "^(out of scope|deferred|future work)" && [ ${#item} -ge 10 ]; then
+    VALID_ITEMS=$((VALID_ITEMS + 1))
+    echo -e "  ${GREEN}✓${NC} Valid item ($VALID_ITEMS): ${item:0:60}..."
+  else
+    echo -e "  ${YELLOW}↷${NC} Filtered out: ${item:0:60}..."
+  fi
+done <<< "$DEFERRED_ITEMS"
+
+if [ $VALID_ITEMS -eq 4 ]; then
+  echo -e "${GREEN}✅ Correctly filtered to $VALID_ITEMS valid items${NC}"
+else
+  echo -e "${YELLOW}⚠️  Expected 4 items, got $VALID_ITEMS${NC}"
+fi
+
+# Test 4: Mock backlog skill invocation (dry run)
+echo -e "\n${YELLOW}Test 4: Testing backlog skill invocation (dry run)...${NC}"
+
+# Check if backlog skill exists
+BACKLOG_SKILL="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-backlog-management/add-backlog-item.sh"
+
+if [ -f "$BACKLOG_SKILL" ]; then
+  echo -e "${GREEN}✅ Backlog skill found: $BACKLOG_SKILL${NC}"
+
+  # Test with one sample item (dry run - check parameters only)
+  SAMPLE_ITEM="Advanced logging with structured JSON format"
+
+  echo -e "${YELLOW}  Testing parameter construction...${NC}"
+  echo "  Command: $BACKLOG_SKILL \\"
+  echo "    --item \"$SAMPLE_ITEM\" \\"
+  echo "    --why \"Deferred during Product Owner decision (Task: test-task-123, Iteration: 1)\" \\"
+  echo "    --solution \"To be determined during sprint planning\" \\"
+  echo "    --priority \"P2\" \\"
+  echo "    --category \"Technical-Debt\" \\"
+  echo "    --sprint \"Sprint-Backlog-1\" \\"
+  echo "    --force"
+
+  echo -e "${GREEN}✅ Parameter construction valid${NC}"
+else
+  echo -e "${RED}❌ Backlog skill not found at: $BACKLOG_SKILL${NC}"
+  exit 1
+fi
+
+# Test 5: Integration point verification
+echo -e "\n${YELLOW}Test 5: Verifying integration point in execute-decision.sh...${NC}"
+
+SCRIPT_PATH="/mnt/c/Users/masha/Documents/claude-flow-novice/.claude/skills/cfn-product-owner-decision/execute-decision.sh"
+
+if grep -q "Processing deferred items for backlog" "$SCRIPT_PATH"; then
+  echo -e "${GREEN}✅ Integration point found in execute-decision.sh${NC}"
+
+  # Check if backlog skill is invoked
+  if grep -q "cfn-backlog-management/add-backlog-item.sh" "$SCRIPT_PATH"; then
+    echo -e "${GREEN}✅ Backlog skill invocation found${NC}"
+  else
+    echo -e "${RED}❌ Backlog skill invocation missing${NC}"
+    exit 1
+  fi
+
+  # Check if error handling is present
+  if grep -q "set +e" "$SCRIPT_PATH" && grep -q "set -e" "$SCRIPT_PATH"; then
+    echo -e "${GREEN}✅ Defensive error handling found${NC}"
+  else
+    echo -e "${YELLOW}⚠️  Error handling may be missing${NC}"
+  fi
+else
+  echo -e "${RED}❌ Integration point not found in execute-decision.sh${NC}"
+  exit 1
+fi
+
+# Summary
+echo -e "\n${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${GREEN}✅ All tests passed!${NC}"
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "\nBacklog integration features verified:"
+echo "  - Deferred section extraction: ✓"
+echo "  - Item parsing and filtering: ✓"
+echo "  - Backlog skill invocation: ✓"
+echo "  - Integration point in execute-decision.sh: ✓"
+echo "  - Defensive error handling: ✓"
+echo ""
+echo "Expected behavior:"
+echo "  - When Product Owner output contains 'Out of Scope', 'Deferred', or 'Future Work' sections"
+echo "  - Items are extracted (lines starting with -, *, or •)"
+echo "  - Each item is added to readme/BACKLOG.md with P2 priority"
+echo "  - Metadata stored in Redis (backlog_items_added)"
+echo "  - Failures are non-blocking (warnings only)"

package/README.md

@@ -19,7 +19,7 @@ cp CFN-CLAUDE.md CLAUDE.md
 npx cfn-loop "Implement JWT authentication system" --mode=standard
 
 # Or spawn agents directly
-npx cfn-spawn backend-dev --task-id auth-task
+npx cfn-spawn backend-developer --task-id auth-task
 ```
 
 **What happens on install**:
@@ -76,7 +76,7 @@ User Task Description
 │                                                           │
 │  ┌─────────────────────────────────────────────┐        │
 │  │ Loop 3: Implementation (parallel agents)    │        │
-│  │ • backend-dev, coder, devops-engineer, etc  │        │
+│  │ • backend-developer, coder, devops-engineer, etc  │        │
 │  │ • Each reports confidence score (0.0-1.0)   │        │
 │  └─────────────────┬───────────────────────────┘        │
 │                    ↓                                      │
@@ -240,7 +240,7 @@ User Task Description
 
 **Implementation**
 - `coder` - General-purpose code implementation
-- `backend-dev` - Backend services and APIs
+- `backend-developer` - Backend services and APIs
 - `frontend-dev` - Frontend applications
 - `mobile-dev` - React Native and cross-platform
 - `rust-developer` - Rust language specialist
@@ -348,7 +348,7 @@ cfn-redis          # Redis coordination utilities
 ## 📊 Multi-Domain Support (6 Task Types)
 
 ### 1. Software Development
-**Agents**: backend-dev, coder, devops-engineer, security-specialist
+**Agents**: backend-developer, coder, devops-engineer, security-specialist
 **Validation**: Tests pass, security scan clean, build succeeds, coverage ≥80%
 **Deliverables**: Source files, test files, docs