claude-flow-novice 2.14.6 → 2.14.8

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

@@ -1,10 +1,15 @@
 #!/bin/bash
-# Product Owner Decision Skill - Main Execution Wrapper
-# Guarantees decision execution via output parsing (solves BUG #11)
+# Product Owner Decision Execution Script
+# Version: 1.0.0
+# Purpose: Execute Product Owner decision with guaranteed Redis coordination
 
 set -euo pipefail
 
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
 
 # Parse arguments
 TASK_ID=""
@@ -14,7 +19,6 @@ THRESHOLD=""
 ITERATION=""
 MAX_ITERATIONS=""
 SUCCESS_CRITERIA=""
-EXPECTED_FILES=""
 
 while [[ $# -gt 0 ]]; do
   case $1 in
@@ -46,12 +50,8 @@ while [[ $# -gt 0 ]]; do
       SUCCESS_CRITERIA="$2"
       shift 2
       ;;
-    --expected-files)
-      EXPECTED_FILES="$2"
-      shift 2
-      ;;
     *)
-      echo "Unknown option: $1" >&2
+      echo "Unknown parameter: $1"
       exit 1
       ;;
   esac
@@ -60,142 +60,236 @@ done
 # Validate required parameters
 if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONSENSUS" ] || \
    [ -z "$THRESHOLD" ] || [ -z "$ITERATION" ] || [ -z "$MAX_ITERATIONS" ]; then
-  echo "ERROR: Missing required parameters" >&2
-  echo "Usage: $0 --task-id TASK_ID --agent-id AGENT_ID --consensus CONSENSUS --threshold THRESHOLD --iteration ITERATION --max-iterations MAX_ITERATIONS [--success-criteria JSON]" >&2
+  echo -e "${RED}❌ ERROR: Missing required parameters${NC}"
+  echo "Usage: $0 --task-id <id> --agent-id <id> --consensus <score> --threshold <score> --iteration <num> --max-iterations <num>"
   exit 1
 fi
 
-# Retrieve full context from Redis (if available)
-REDIS_CONTEXT=$(redis-cli HGET "cfn_loop:task:${TASK_ID}:context" "full_context" 2>/dev/null || echo "{}")
+echo -e "${GREEN}🎯 Product Owner Decision Execution${NC}"
+echo "Task ID: $TASK_ID"
+echo "Agent ID: $AGENT_ID"
+echo "Consensus: $CONSENSUS"
+echo "Threshold: $THRESHOLD"
+echo "Iteration: $ITERATION / $MAX_ITERATIONS"
 
-# Extract scope from Redis context
-EPIC_GOAL=$(echo "$REDIS_CONTEXT" | jq -r '.epicGoal // "Task completion"')
-IN_SCOPE=$(echo "$REDIS_CONTEXT" | jq -r '.inScope[]?' | sed 's/^/- /' | tr '\n' '\n' || echo "- Core functionality")
-OUT_SCOPE=$(echo "$REDIS_CONTEXT" | jq -r '.outOfScope[]?' | sed 's/^/- /' | tr '\n' '\n' || echo "- Advanced features")
-DELIVERABLES=$(echo "$REDIS_CONTEXT" | jq -r '.deliverables[]?' | sed 's/^/- /' | tr '\n' '\n' || echo "- Implementation files")
-DIRECTORY=$(echo "$REDIS_CONTEXT" | jq -r '.directory // "."')
-ACCEPTANCE=$(echo "$REDIS_CONTEXT" | jq -r '.acceptanceCriteria[]?' | sed 's/^/- /' | tr '\n' '\n' || echo "- Tests pass")
+# Retrieve Loop 2 context from Redis
+echo -e "${YELLOW}📥 Retrieving Loop 2 context...${NC}"
+LOOP2_FEEDBACK=$(redis-cli HGET "swarm:${TASK_ID}:loop2:consensus" "feedback" || echo "")
+TASK_CONTEXT=$(redis-cli HGETALL "swarm:${TASK_ID}:context" || echo "")
 
-# Build Product Owner context with full scope information
-PO_CONTEXT="CFN Loop iteration $ITERATION complete.
+# Build Product Owner context
+PO_CONTEXT="
+You are the Product Owner making a strategic decision for CFN Loop iteration $ITERATION of $MAX_ITERATIONS.
 
-Epic Goal: $EPIC_GOAL
+Loop 2 Consensus: $CONSENSUS
+Threshold: $THRESHOLD
+Success Criteria: ${SUCCESS_CRITERIA:-"Not specified"}
 
-In-Scope:
-$IN_SCOPE
+Loop 2 Feedback:
+$LOOP2_FEEDBACK
 
-Out-of-Scope:
-$OUT_SCOPE
+Task Context:
+$TASK_CONTEXT
 
-Deliverables:
-$DELIVERABLES
+Make a strategic decision:
+- PROCEED: Quality threshold met, deliverables complete
+- ITERATE: Improvements needed, iterations remaining
+- ABORT: Max iterations reached or unrecoverable failure
 
-Directory: $DIRECTORY
-
-Acceptance Criteria:
-$ACCEPTANCE
+Output format:
+Decision: PROCEED|ITERATE|ABORT
+Reasoning: [your explanation]
+Confidence: [0.0-1.0]
+"
 
-Loop 2 Consensus: $CONSENSUS (threshold: $THRESHOLD)
-Current Iteration: $ITERATION
-Max Iterations: $MAX_ITERATIONS
+# Spawn Product Owner agent
+echo -e "${YELLOW}🚀 Spawning Product Owner agent...${NC}"
+PO_OUTPUT_FILE="/tmp/product-owner-${TASK_ID}-${ITERATION}.log"
 
-Make your strategic decision: PROCEED, ITERATE, or ABORT
+# Use timeout from agent config
+PO_TIMEOUT=300  # 5 minutes default
 
-Decision Framework:
-- PROCEED: Consensus >= $THRESHOLD AND deliverables verified AND acceptance criteria met
-- ITERATE: Consensus < $THRESHOLD AND iteration < $MAX_ITERATIONS
-- ABORT: Max iterations reached without consensus
+set +e
+timeout "$PO_TIMEOUT" npx claude-flow-novice agent product-owner \
+  --task-id "$TASK_ID" \
+  --context "$PO_CONTEXT" > "$PO_OUTPUT_FILE" 2>&1
+PO_EXIT_CODE=$?
+set -e
 
-Output format:
-Decision: [PROCEED|ITERATE|ABORT]
-Reasoning: [explain using GOAP framework]
-Confidence: [0.0-1.0]
-Next Action: [specific next step - 'proceed to next sprint', 'complete epic', 'iterate on current sprint']
+# Check timeout
+if [ $PO_EXIT_CODE -eq 124 ]; then
+  echo -e "${RED}❌ ERROR: Product Owner timed out after ${PO_TIMEOUT}s${NC}"
+  DECISION_TYPE="ABORT"
+  REASONING="Product Owner decision timeout after ${PO_TIMEOUT}s"
+  CONFIDENCE=0.0
+else
+  # Parse decision from output
+  # Defensive file handling - TEST 5 fix
+  if [ -f "$PO_OUTPUT_FILE" ] && [ -s "$PO_OUTPUT_FILE" ]; then
+    PO_OUTPUT=$(cat "$PO_OUTPUT_FILE")
 
-CRITICAL: Do NOT ask for user confirmation. Make autonomous decision."
+    # 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 "")
 
-# Get agent timeout (if get_agent_timeout function available)
-if command -v get_agent_timeout &>/dev/null; then
-  PO_TIMEOUT=$(get_agent_timeout "product-owner" "$TASK_ID")
-else
-  PO_TIMEOUT=900  # Default 15 minutes
-fi
+    if [ -z "$DECISION_TYPE" ]; then
+      DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oE "(PROCEED|ITERATE|ABORT)" | head -1 || echo "")
+    fi
 
-# Spawn Product Owner and capture output
-PO_OUTPUT=$(timeout "$PO_TIMEOUT" npx claude-flow-novice agent product-owner \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "$PO_CONTEXT" 2>&1 || true)
+    if [ -z "$DECISION_TYPE" ]; then
+      DECISION_TYPE=$(echo "$PO_OUTPUT" | grep -oiE "(proceed|iterate|abort)" | head -1 | tr '[:lower:]' '[:upper:]' || echo "")
+    fi
 
-# Parse decision using skill parser
-DECISION_TYPE=$("$SCRIPT_DIR/parse-decision.sh" --output "$PO_OUTPUT")
+    # 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
 if [ -z "$DECISION_TYPE" ]; then
-  echo "❌ ERROR: Could not parse Product Owner decision" >&2
-  echo "Product Owner output:" >&2
-  echo "$PO_OUTPUT" >&2
-
-  # Fallback to ABORT on parse failure
+  echo -e "${RED}❌ ERROR: Could not parse decision from Product Owner output${NC}"
+  echo "Output sample:"
+  echo "$PO_OUTPUT" | head -20
   DECISION_TYPE="ABORT"
-  REASONING="Failed to parse Product Owner decision from output"
-  CONFIDENCE=0.50
-else
-  # Extract reasoning (context around decision)
-  REASONING=$(echo "$PO_OUTPUT" | grep -A5 -i "decision" | tail -5 | tr '\n' ' ' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
-  CONFIDENCE=0.90
+  REASONING="Failed to parse Product Owner decision"
+  CONFIDENCE=0.0
 fi
 
-# Validate deliverables for PROCEED decisions
+echo -e "${GREEN}✅ Product Owner Decision: $DECISION_TYPE${NC}"
+echo "Reasoning: $REASONING"
+echo "Confidence: $CONFIDENCE"
+
+# Deliverable verification for PROCEED decisions
 if [ "$DECISION_TYPE" = "PROCEED" ]; then
-  DELIVERABLE_ARGS="--task-id $TASK_ID"
-  if [ -n "$EXPECTED_FILES" ]; then
-    DELIVERABLE_ARGS="$DELIVERABLE_ARGS --expected-files $EXPECTED_FILES"
+  echo -e "${YELLOW}🔍 Verifying deliverables...${NC}"
+
+  # Check if task requires implementation (keywords: create, build, implement, generate)
+  REQUIRES_IMPLEMENTATION=$(echo "$TASK_CONTEXT" | grep -iE "(create|build|implement|generate|write|add)" || echo "")
+
+  if [ -n "$REQUIRES_IMPLEMENTATION" ]; then
+    # Check git status for file changes
+    FILES_CHANGED=$(git status --short | grep -E "^(A|M|\?\?)" | wc -l || echo "0")
+
+    if [ "$FILES_CHANGED" -eq 0 ]; then
+      echo -e "${YELLOW}⚠️  WARNING: No deliverables created (consensus on plans only)${NC}"
+      DECISION_TYPE="ITERATE"
+      REASONING="Override PROCEED → ITERATE: No files created despite implementation task. Validators approved plans without actual code."
+      CONFIDENCE=0.70
+
+      # Add deliverable requirement to feedback
+      DELIVERABLE_FEEDBACK="
+Critical: Task requires implementation but zero files created.
+Next iteration MUST create actual deliverables, not just plans.
+"
+      redis-cli HSET "swarm:${TASK_ID}:loop2:consensus" "deliverable_feedback" "$DELIVERABLE_FEEDBACK"
+    else
+      echo -e "${GREEN}✅ Deliverables verified: $FILES_CHANGED files changed${NC}"
+    fi
   fi
+fi
 
-  DELIVERABLE_STATUS=$("$SCRIPT_DIR/validate-deliverables.sh" $DELIVERABLE_ARGS)
-
-  if [ "$DELIVERABLE_STATUS" = "FAILED" ]; then
-    # Retrieve missing files from Redis (if available)
-    MISSING_FILES_JSON=$(redis-cli get "swarm:${TASK_ID}:missing-files" 2>/dev/null || echo "[]")
-    MISSING_FILES_LIST=$(echo "$MISSING_FILES_JSON" | jq -r '.[]' | tr '\n' ', ' | sed 's/,$//')
-
-    # Override PROCEED → ITERATE
-    DECISION_TYPE="ITERATE"
-    if [ -n "$MISSING_FILES_LIST" ]; then
-      REASONING="Deliverable verification failed - missing files: $MISSING_FILES_LIST"
+# 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
-      REASONING="Deliverable verification failed - no files created (consensus on plans only)"
+      echo -e "${YELLOW}⚠️  No valid backlog items extracted${NC}"
     fi
-    CONFIDENCE=0.75
+  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=$(jq -n \
-  --arg decision "$DECISION_TYPE" \
-  --arg reasoning "${REASONING:-Parsed from Product Owner output}" \
-  --arg confidence "$CONFIDENCE" \
-  --arg iteration "$ITERATION" \
-  --arg consensus "$CONSENSUS" \
-  '{
-    decision: $decision,
-    reasoning: $reasoning,
-    confidence: ($confidence | tonumber),
-    iteration: ($iteration | tonumber),
-    consensus: ($consensus | tonumber),
-    timestamp: (now | todate)
-  }')
-
-# Push decision to Redis (orchestrator's responsibility, not agent's)
-DECISION_KEY="swarm:${TASK_ID}:${AGENT_ID}:decision"
-echo "$DECISION_JSON" | redis-cli -x LPUSH "$DECISION_KEY" >/dev/null
-
-# Signal Product Owner completion
-redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" >/dev/null
-
-# Store decision in metrics
-redis-cli LPUSH "swarm:${TASK_ID}:metrics:product_owner_decisions" "$DECISION_JSON" >/dev/null
-redis-cli INCR "swarm:metrics:decisions:$(echo "$DECISION_TYPE" | tr '[:upper:]' '[:lower:]')" >/dev/null
+DECISION_JSON=$(cat <<EOF
+{
+  "decision": "$DECISION_TYPE",
+  "reasoning": "$REASONING",
+  "confidence": $CONFIDENCE,
+  "iteration": $ITERATION,
+  "consensus": $CONSENSUS,
+  "threshold": $THRESHOLD,
+  "timestamp": $(date +%s)
+}
+EOF
+)
+
+# Store decision in Redis
+echo -e "${YELLOW}💾 Storing decision in Redis...${NC}"
+redis-cli LPUSH "swarm:${TASK_ID}:decision" "$DECISION_TYPE"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "decision" "$DECISION_TYPE"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "reasoning" "$REASONING"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "confidence" "$CONFIDENCE"
+
+# Store in metrics
+redis-cli LPUSH "swarm:${TASK_ID}:metrics:product_owner_decisions" "$DECISION_JSON"
+redis-cli INCR "swarm:metrics:decisions:$(echo "$DECISION_TYPE" | tr '[:upper:]' '[:lower:]')"
+
+# Signal completion
+redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+
+# Report confidence (for orchestrator collection)
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence "$CONFIDENCE" \
+  --iteration "$ITERATION"
 
 # Output decision JSON for orchestrator
 echo "$DECISION_JSON"
+
+echo -e "${GREEN}✅ Product Owner decision execution complete${NC}"

package/claude-assets/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/claude-assets/skills/cfn-redis-coordination/report-completion.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Report agent completion and confidence to Redis
+# Replaces deprecated invoke-waiting-mode.sh for CFN Loop coordination
+#
+# Usage: report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>]
+
+set -euo pipefail
+
+# Parse arguments
+TASK_ID=""
+AGENT_ID=""
+CONFIDENCE=""
+RESULT=""
+ITERATION="1"
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --task-id)
+            TASK_ID="$2"
+            shift 2
+            ;;
+        --agent-id)
+            AGENT_ID="$2"
+            shift 2
+            ;;
+        --confidence)
+            CONFIDENCE="$2"
+            shift 2
+            ;;
+        --result)
+            RESULT="$2"
+            shift 2
+            ;;
+        --iteration)
+            ITERATION="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown option: $1" >&2
+            exit 1
+            ;;
+    esac
+done
+
+# Validate required parameters
+if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
+    echo "Error: Missing required parameters" >&2
+    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>] [--iteration <n>]" >&2
+    exit 1
+fi
+
+# Validate confidence range
+if ! awk -v conf="$CONFIDENCE" 'BEGIN { if (conf < 0 || conf > 1) exit 1 }'; then
+    echo "Error: Confidence must be between 0.0 and 1.0" >&2
+    exit 1
+fi
+
+# Step 1: Signal completion (LPUSH for BLPOP coordination)
+redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" > /dev/null
+
+# Step 2: Store confidence score (STRING key for fast access)
+redis-cli SET "swarm:${TASK_ID}:${AGENT_ID}:confidence" "$CONFIDENCE" EX 3600 > /dev/null
+
+# Step 3: Store result in hash (structured data)
+if [ -n "$RESULT" ]; then
+    redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
+        "confidence" "$CONFIDENCE" \
+        "iteration" "$ITERATION" \
+        "result" "$RESULT" \
+        "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
+else
+    redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
+        "confidence" "$CONFIDENCE" \
+        "iteration" "$ITERATION" \
+        "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
+fi
+
+# Step 4: Add to agent completion list (for orchestrator tracking)
+redis-cli LPUSH "swarm:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
+
+# Set TTL on hash
+redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
+redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
+
+echo "✅ Reported completion for agent: $AGENT_ID (confidence: $CONFIDENCE)"
+exit 0

package/claude-assets/skills/cfn-redis-coordination/store-context.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Store CFN Loop task context in Redis
+# Used by orchestrator to pass context to CLI-spawned agents
+#
+# Usage: store-context.sh <task_id> <context_json>
+
+set -euo pipefail
+
+TASK_ID="${1:-}"
+CONTEXT="${2:-}"
+
+if [ -z "$TASK_ID" ]; then
+    echo "Error: TASK_ID required" >&2
+    echo "Usage: $0 <task_id> <context_json>" >&2
+    exit 1
+fi
+
+if [ -z "$CONTEXT" ]; then
+    echo "Error: CONTEXT required" >&2
+    echo "Usage: $0 <task_id> <context_json>" >&2
+    exit 1
+fi
+
+# Store context in Redis
+redis-cli HSET "cfn_loop:task:${TASK_ID}:context" \
+    "task_description" "$CONTEXT" \
+    "stored_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+    > /dev/null
+
+# Set TTL (24 hours)
+redis-cli EXPIRE "cfn_loop:task:${TASK_ID}:context" 86400 > /dev/null
+
+echo "✅ Context stored for task: $TASK_ID"
+exit 0

package/claude-assets/skills/cfn-task-classifier/SKILL.md

@@ -91,4 +91,4 @@ classify-task.sh "Build ETL pipeline for customer data warehouse"
 
 Used by:
 - `.claude/agents/cfn-v3-coordinator.md` - Task analysis
-- `.claude/skills/agent-selector/select-agents.sh` - Agent recommendation
+- `.claude/skills/cfn-agent-selector/select-agents.sh` - Agent recommendation