claude-flow-novice 2.14.6 → 2.14.8

package/.claude/commands/cfn/run-tests.md

@@ -0,0 +1,119 @@
+---
+name: run-tests
+description: Run CFN test suites with benchmarking and regression detection
+category: testing
+---
+
+# Run CFN Tests
+
+Execute CFN test suites (Hello World + CFN E2E) with automatic benchmarking and regression detection.
+
+## Usage
+
+```bash
+# Run all tests
+/run-tests
+
+# Run specific suite
+/run-tests hello-world
+/run-tests cfn-e2e
+
+# With benchmarking
+/run-tests --benchmark
+
+# With regression detection
+/run-tests --detect-regressions --threshold 0.10
+```
+
+## Execution
+
+```bash
+./.claude/skills/cfn-test-runner/run-all-tests.sh \
+  --suite {{arg1:-all}} \
+  {{#if benchmark}}--benchmark{{/if}} \
+  {{#if detect-regressions}}--detect-regressions --threshold {{threshold:-0.10}}{{/if}}
+```
+
+## Test Suites
+
+### Hello World (4 tests)
+- Layer 0: Tool Validation (60s)
+- Layer 5: Coordinator Spawning (120s)
+- Layer 6: Review Handoff (180s)
+- Layer 7: Error Retry (150s)
+
+### CFN E2E (9 tests)
+- Coordinator → Orchestrator handoff
+- Loop 3 → Gate Check
+- Gate Pass → Loop 2
+- Loop 2 → Product Owner
+- Product Owner Decision
+- Iteration Cycle
+- Redis Key Structure
+- Error Recovery
+- Cleanup
+
+## Benchmarking
+
+Results stored in `.artifacts/test-benchmarks.db`:
+- Test run history (30 days)
+- Success rate trends
+- Duration tracking
+- Git commit correlation
+
+## Regression Detection
+
+Automatic alerts for:
+- Test failures (was passing)
+- Performance degradation (>10% slower)
+- Success rate drops (>10% decrease)
+
+View regressions:
+```sql
+sqlite3 .artifacts/test-benchmarks.db "SELECT * FROM regression_alerts WHERE acknowledged = 0"
+```
+
+## Examples
+
+**Standard test run:**
+```
+/run-tests
+```
+
+**With full benchmarking:**
+```
+/run-tests --benchmark --detect-regressions
+```
+
+**Specific suite only:**
+```
+/run-tests cfn-e2e --benchmark
+```
+
+## Output
+
+```
+==========================================
+CFN Test Suite Runner
+==========================================
+Suite: all
+Benchmark: true
+Detect Regressions: true
+Git: main @ abc123
+
+Hello World: 4 passed, 0 failed, 0 skipped (494s)
+CFN E2E: 7 passed, 0 failed, 2 skipped (356s)
+
+==========================================
+Test Summary
+==========================================
+Total: 13 tests
+Passed: 11
+Failed: 0
+Skipped: 2
+Duration: 850s
+Success Rate: 84.6%
+
+✅ Benchmark stored (run_id: 42)
+✅ No regressions detected
+```

package/.claude/hooks/cfn-post-edit.config.json

@@ -3,12 +3,14 @@
   "version": "2.0.0",
   "pipeline": "config/hooks/post-edit-pipeline.js",
   "triggerOn": ["Edit", "Write", "MultiEdit"],
-  "fileTypes": [".ts", ".tsx", ".js", ".jsx", ".json", ".md"],
+  "fileTypes": [".ts", ".tsx", ".js", ".jsx", ".json", ".md", ".sh", ".bash", ".py", ".rs"],
   "blocking": false,
   "exitCodes": {
     "0": "SUCCESS",
     "1": "ERROR",
-    "2": "SYNTAX_ERROR"
+    "2": "SYNTAX_ERROR",
+    "9": "BASH_VALIDATOR_ERROR",
+    "10": "BASH_VALIDATOR_WARNING"
   },
   "redis": {
     "enabled": true,
@@ -26,12 +28,17 @@
       "enabled": true,
       "noEmit": true,
       "skipLibCheck": true
+    },
+    "bash": {
+      "enabled": true,
+      "validators": ["pipe-safety", "dependency-checker", "line-endings"],
+      "timeout": 5000
     }
   },
   "feedback": {
     "provideSuggestions": true,
     "autoFixable": ["LINT_ISSUES"],
-    "nonBlocking": ["TYPE_WARNING", "LINT_ISSUES"],
-    "blocking": ["SYNTAX_ERROR"]
+    "nonBlocking": ["TYPE_WARNING", "LINT_ISSUES", "BASH_VALIDATOR_WARNING"],
+    "blocking": ["SYNTAX_ERROR", "BASH_VALIDATOR_ERROR"]
   }
 }

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

@@ -13,7 +13,7 @@ Recommends Loop 3 (producers) and Loop 2 (evaluators) agents based on:
 ## Usage
 
 ```bash
-AGENTS=$(./.claude/skills/agent-selector/select-agents.sh \
+AGENTS=$(./.claude/skills/cfn-agent-selector/select-agents.sh \
   --task-type "software-development" \
   --description "Implement JWT authentication with refresh tokens")
 
@@ -87,4 +87,5 @@ echo "$AGENTS" | jq '.loop2[]'  # ["reviewer", "tester", "security-auditor"]
 ## Integration
 
 Used by:
-- `.claude/agents/cfn-v3-coordinator.md` - Agent selection
+- `.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

@@ -635,7 +635,7 @@ function spawn_product_owner() {
   # BLOCKER #2 FIX: Match execute-decision.sh actual parameters
   # Required: --task-id, --agent-id, --consensus, --threshold, --iteration, --max-iterations
   local decision_output
-  decision_output=$("$SCRIPT_DIR/.claude/skills/cfn-cfn-product-owner-decision/execute-decision.sh" \
+  decision_output=$("$SCRIPT_DIR/.claude/skills/cfn-product-owner-decision/execute-decision.sh" \
     --task-id "$task_id" \
     --agent-id "$PRODUCT_OWNER" \
     --consensus "$LOOP2_FINAL_CONSENSUS" \

package/.claude/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}"