claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/product-owner-decision/SKILL.md

@@ -0,0 +1,332 @@
+# Product Owner Decision Skill
+
+**Version:** 1.0.0
+**Status:** Production
+**Purpose:** Strategic decision-making for CFN Loop progression with guaranteed execution
+
+---
+
+## Overview
+
+Provides autonomous Product Owner decision execution with:
+- **Guaranteed Redis coordination** (orchestrator-controlled)
+- **Output parsing with fallback patterns**
+- **Decision validation** (ensures PROCEED/ITERATE/ABORT detection)
+- **Context injection** (consensus, iteration, success criteria)
+
+**Key Principle:** Orchestrator controls Redis coordination, agents focus on decision analysis.
+
+---
+
+## Architecture
+
+### Skill Components
+
+```
+.claude/skills/product-owner-decision/
+├── SKILL.md                          # This file
+├── execute-decision.sh               # Main decision execution wrapper
+├── parse-decision.sh                 # Output parsing with fallback patterns
+└── validate-deliverables.sh          # Deliverable verification logic
+```
+
+### Decision Flow
+
+```
+1. Orchestrator → Spawn Product Owner with context
+2. Skill → Capture agent output
+3. Skill → Parse decision (PROCEED/ITERATE/ABORT)
+4. Skill → Validate deliverables (for PROCEED)
+5. Skill → Push decision to Redis
+6. Skill → Signal completion
+```
+
+---
+
+## Usage
+
+### From Orchestrator (orchestrate-cfn-loop.sh)
+
+```bash
+# Replace Product Owner spawn+wait with skill execution
+DECISION_RESULT=$(./.claude/skills/product-owner-decision/execute-decision.sh \
+  --task-id "$TASK_ID" \
+  --agent-id "$PO_UNIQUE_ID" \
+  --consensus "$LOOP2_CONSENSUS" \
+  --threshold "$CONSENSUS" \
+  --iteration "$ITERATION" \
+  --max-iterations "$MAX_ITERATIONS")
+
+DECISION_TYPE=$(echo "$DECISION_RESULT" | jq -r '.decision')
+```
+
+### From Slash Commands
+
+```bash
+# Automatic - orchestrator uses skill by default
+/cfn-loop "Implement feature" --mode=standard
+```
+
+---
+
+## Parameters
+
+### execute-decision.sh
+
+| Parameter | Required | Description | Example |
+|-----------|----------|-------------|---------|
+| `--task-id` | Yes | CFN Loop task identifier | `cfn-auth-system-123` |
+| `--agent-id` | Yes | Product Owner agent ID | `product-owner-1` |
+| `--consensus` | Yes | Loop 2 consensus score | `0.92` |
+| `--threshold` | Yes | Consensus threshold | `0.90` |
+| `--iteration` | Yes | Current iteration number | `2` |
+| `--max-iterations` | Yes | Max iterations allowed | `10` |
+| `--success-criteria` | No | JSON success criteria | `{"tests":"pass"}` |
+
+---
+
+## Decision Logic (GOAP Framework)
+
+### PROCEED
+```bash
+Consensus >= Threshold
+AND Deliverables exist (for implementation tasks)
+AND Iteration <= Max
+```
+
+### ITERATE
+```bash
+Consensus < Threshold
+AND Iteration < Max
+```
+
+### ABORT
+```bash
+Iteration >= Max
+OR Unrecoverable failure
+```
+
+---
+
+## Output Parsing
+
+### Pattern Matching (Robust)
+
+```bash
+# Primary: Labeled decision
+grep -oiE "Decision:\s*(PROCEED|ITERATE|ABORT)"
+
+# Fallback 1: Standalone keyword
+grep -oE "(PROCEED|ITERATE|ABORT)"
+
+# Fallback 2: Case-insensitive variations
+grep -oiE "(proceed|iterate|abort)"
+```
+
+### Validation
+
+```bash
+if [ -z "$DECISION_TYPE" ]; then
+  echo "❌ ERROR: Could not parse decision"
+  echo "Product Owner output: $PO_OUTPUT"
+  exit 1
+fi
+```
+
+---
+
+## Deliverable Verification
+
+### For PROCEED Decisions
+
+```bash
+# Check git status for file changes
+FILES_CHANGED=$(git status --short | grep -E "^(A|M|\?\?)" | wc -l)
+
+if [ "$FILES_CHANGED" -eq 0 ]; then
+  # Override PROCEED → ITERATE
+  DECISION_TYPE="ITERATE"
+  REASONING="No deliverables created - consensus on plans only"
+fi
+```
+
+---
+
+## Redis Coordination
+
+### Keys Used
+
+```bash
+# Decision storage
+swarm:${TASK_ID}:${AGENT_ID}:decision
+
+# Completion signal
+swarm:${TASK_ID}:${AGENT_ID}:done
+
+# Metrics
+swarm:${TASK_ID}:metrics:product_owner_decisions
+```
+
+### Decision JSON Format
+
+```json
+{
+  "decision": "PROCEED|ITERATE|ABORT",
+  "reasoning": "Explanation of decision",
+  "confidence": 0.90,
+  "iteration": 2,
+  "consensus": 0.92,
+  "deliverables_verified": true
+}
+```
+
+---
+
+## Error Handling
+
+### Agent Timeout
+```bash
+# Use agent-specific timeout
+PO_TIMEOUT=$(get_agent_timeout "product-owner" "$TASK_ID")
+timeout "$PO_TIMEOUT" npx claude-flow-novice agent product-owner ...
+```
+
+### Parse Failure
+```bash
+# Fallback to ABORT with error context
+DECISION_TYPE="ABORT"
+REASONING="Failed to parse Product Owner decision after $RETRY_COUNT attempts"
+```
+
+### Deliverable Verification Failure
+```bash
+# Override PROCEED → ITERATE
+DECISION_TYPE="ITERATE"
+REASONING="Deliverable verification failed - no files created"
+```
+
+---
+
+## Testing
+
+### Unit Tests
+
+```bash
+# Test decision parsing
+./.claude/skills/product-owner-decision/test-parse-decision.sh
+
+# Test deliverable verification
+./.claude/skills/product-owner-decision/test-deliverable-verification.sh
+```
+
+### Integration Tests
+
+```bash
+# Test full CFN Loop with Product Owner decisions
+./.claude/skills/redis-coordination/test-orchestrator.sh
+```
+
+---
+
+## Advantages Over Template-Based Approach
+
+| Aspect | Template-Based | Skill-Based |
+|--------|----------------|-------------|
+| **Execution Guarantee** | ❌ Agent decides | ✅ Script enforces |
+| **Redis Coordination** | ❌ Agent must execute | ✅ Orchestrator controls |
+| **Output Parsing** | ❌ None | ✅ Robust fallback patterns |
+| **Deliverable Verification** | ❌ Manual | ✅ Automated |
+| **Error Handling** | ❌ Agent-dependent | ✅ Skill-controlled |
+| **Testability** | ❌ Hard to test | ✅ Unit + integration tests |
+
+---
+
+## Migration from Template-Based
+
+### Before (BUG #11)
+```markdown
+## Decision Execution Protocol (CRITICAL)
+**YOUR TASK:** Use the Bash tool to execute:
+bash ./.claude/skills/redis-coordination/execute-product-owner-decision.sh
+```
+
+Agent output: `bash execute-product-owner-decision.sh` (NOT executed)
+
+### After (Skill-Based)
+```bash
+# Orchestrator uses skill directly
+DECISION_RESULT=$(./.claude/skills/product-owner-decision/execute-decision.sh \
+  --task-id "$TASK_ID" ...)
+```
+
+Skill executes, parses, validates, pushes to Redis → Guaranteed
+
+---
+
+## Agent Template Simplification
+
+Product Owner template becomes pure decision analysis:
+
+```markdown
+## Decision Framework
+
+Make strategic decision for CFN Loop progression:
+
+- **PROCEED:** Quality threshold met, deliverables complete
+- **ITERATE:** Improvements needed, iterations remaining
+- **ABORT:** Max iterations reached or unrecoverable failure
+
+Consider:
+- Loop 2 consensus vs threshold
+- Current iteration vs max iterations
+- Deliverable completeness
+- Success criteria satisfaction
+
+Output format:
+Decision: PROCEED|ITERATE|ABORT
+Reasoning: [explanation]
+```
+
+Agent focuses on **analysis**, skill handles **execution**.
+
+---
+
+## Metrics
+
+### Decision Tracking
+```bash
+# Store all Product Owner decisions
+redis-cli LPUSH "swarm:${TASK_ID}:metrics:product_owner_decisions" "$DECISION_JSON"
+
+# Count decision types
+redis-cli INCR "swarm:metrics:decisions:proceed"
+redis-cli INCR "swarm:metrics:decisions:iterate"
+redis-cli INCR "swarm:metrics:decisions:abort"
+```
+
+### Performance
+```bash
+# Decision latency (time from Loop 2 complete to decision)
+DECISION_START=$(date +%s)
+DECISION_RESULT=$(execute-decision.sh ...)
+DECISION_END=$(date +%s)
+LATENCY=$((DECISION_END - DECISION_START))
+```
+
+---
+
+## Related Skills
+
+- **Redis Coordination** (`.claude/skills/redis-coordination/SKILL.md`)
+- **CFN Loop Validation** (`.claude/skills/cfn-loop-validation/SKILL.md`)
+
+---
+
+## Version History
+
+### 1.0.0 (2025-10-20)
+- Initial skill creation
+- Solves BUG #11 (Product Owner execution failure)
+- Orchestrator-controlled decision execution
+- Robust output parsing with fallbacks
+- Automated deliverable verification

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

@@ -0,0 +1,176 @@
+#!/bin/bash
+# Product Owner Decision Skill - Main Execution Wrapper
+# Guarantees decision execution via output parsing (solves BUG #11)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Parse arguments
+TASK_ID=""
+AGENT_ID=""
+CONSENSUS=""
+THRESHOLD=""
+ITERATION=""
+MAX_ITERATIONS=""
+SUCCESS_CRITERIA=""
+EXPECTED_FILES=""
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --agent-id)
+      AGENT_ID="$2"
+      shift 2
+      ;;
+    --consensus)
+      CONSENSUS="$2"
+      shift 2
+      ;;
+    --threshold)
+      THRESHOLD="$2"
+      shift 2
+      ;;
+    --iteration)
+      ITERATION="$2"
+      shift 2
+      ;;
+    --max-iterations)
+      MAX_ITERATIONS="$2"
+      shift 2
+      ;;
+    --success-criteria)
+      SUCCESS_CRITERIA="$2"
+      shift 2
+      ;;
+    --expected-files)
+      EXPECTED_FILES="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+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
+  exit 1
+fi
+
+# Build Product Owner context
+PO_CONTEXT="CFN Loop iteration $ITERATION complete.
+
+Loop 2 Consensus: $CONSENSUS (threshold: $THRESHOLD)
+Task ID: $TASK_ID
+Agent ID: $AGENT_ID
+Max Iterations: $MAX_ITERATIONS
+
+Make your strategic decision: PROCEED, ITERATE, or ABORT
+
+Decision Framework:
+- PROCEED: Consensus >= $THRESHOLD AND deliverables verified
+- ITERATE: Consensus < $THRESHOLD AND iteration < $MAX_ITERATIONS
+- ABORT: Max iterations reached without consensus
+
+Output your decision clearly with reasoning.
+Format: Decision: [PROCEED|ITERATE|ABORT]"
+
+# Inject CFN Loop context if injection script exists
+INJECT_SCRIPT="$SCRIPT_DIR/../cfn-loop-orchestration/inject-loop-context.sh"
+if [[ -x "$INJECT_SCRIPT" ]]; then
+  PO_CONTEXT=$("$INJECT_SCRIPT" "loop4" "$PO_CONTEXT" 2>/dev/null || echo "$PO_CONTEXT")
+fi
+
+# 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
+
+# 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)
+
+# Parse decision using skill parser
+DECISION_TYPE=$("$SCRIPT_DIR/parse-decision.sh" --output "$PO_OUTPUT")
+
+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
+  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
+fi
+
+# Validate deliverables 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"
+  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"
+    else
+      REASONING="Deliverable verification failed - no files created (consensus on plans only)"
+    fi
+    CONFIDENCE=0.75
+  fi
+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
+
+# Output decision JSON for orchestrator
+echo "$DECISION_JSON"

package/.claude/skills/product-owner-decision/parse-decision.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+# Product Owner Decision Parser - Robust pattern matching with fallbacks
+
+set -euo pipefail
+
+# Parse arguments
+OUTPUT=""
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --output)
+      OUTPUT="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "$OUTPUT" ]; then
+  echo "ERROR: --output required" >&2
+  exit 1
+fi
+
+# Pattern 1: Labeled decision (most explicit)
+# Example: "Decision: PROCEED"
+DECISION=$(echo "$OUTPUT" | grep -oiE "Decision:\s*(PROCEED|ITERATE|ABORT)" | \
+  grep -oE "(PROCEED|ITERATE|ABORT)" | head -1)
+
+if [ -n "$DECISION" ]; then
+  echo "$DECISION"
+  exit 0
+fi
+
+# Pattern 2: Standalone keyword (first occurrence)
+# Example: "I recommend we PROCEED with..."
+DECISION=$(echo "$OUTPUT" | grep -oE "(PROCEED|ITERATE|ABORT)" | head -1)
+
+if [ -n "$DECISION" ]; then
+  echo "$DECISION"
+  exit 0
+fi
+
+# Pattern 3: Case-insensitive fallback
+# Example: "proceed with deployment"
+DECISION=$(echo "$OUTPUT" | grep -oiE "(proceed|iterate|abort)" | head -1 | tr '[:lower:]' '[:upper:]')
+
+if [ -n "$DECISION" ]; then
+  echo "$DECISION"
+  exit 0
+fi
+
+# Pattern 4: JSON format fallback
+# Example: {"decision": "PROCEED"}
+DECISION=$(echo "$OUTPUT" | jq -r '.decision // empty' 2>/dev/null | grep -oE "(PROCEED|ITERATE|ABORT)" | head -1)
+
+if [ -n "$DECISION" ]; then
+  echo "$DECISION"
+  exit 0
+fi
+
+# No decision found - return empty (caller handles fallback to ABORT)
+echo ""
+exit 0

package/.claude/skills/product-owner-decision/validate-deliverables.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# Deliverable Verification - Prevent "consensus on vapor"
+
+set -euo pipefail
+
+# Parse arguments
+TASK_ID=""
+EXPECTED_FILES=""
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --expected-files)
+      EXPECTED_FILES="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "$TASK_ID" ]; then
+  echo "ERROR: --task-id required" >&2
+  exit 1
+fi
+
+# Get task description from Redis
+TASK_DESC=$(redis-cli GET "swarm:${TASK_ID}:task" 2>/dev/null || echo "")
+
+# Check if task requires implementation (file creation)
+REQUIRES_FILES=false
+if echo "$TASK_DESC" | grep -qiE "create|build|implement|generate|file|component|module|test|write|add"; then
+  REQUIRES_FILES=true
+fi
+
+# If task doesn't require files, skip verification
+if [ "$REQUIRES_FILES" = false ]; then
+  echo "PASSED"
+  exit 0
+fi
+
+# If expected files specified, verify actual existence
+if [ -n "$EXPECTED_FILES" ]; then
+  MISSING_FILES=()
+  IFS=',' read -ra FILES <<< "$EXPECTED_FILES"
+
+  for file in "${FILES[@]}"; do
+    # Trim whitespace
+    file=$(echo "$file" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+    if [ ! -f "$file" ]; then
+      MISSING_FILES+=("$file")
+    fi
+  done
+
+  if [ ${#MISSING_FILES[@]} -gt 0 ]; then
+    echo "FAILED"
+    # Store missing files in Redis for orchestrator feedback
+    MISSING_JSON=$(printf '%s\n' "${MISSING_FILES[@]}" | jq -R . | jq -s -c .)
+    redis-cli setex "swarm:${TASK_ID}:missing-files" 300 "$MISSING_JSON" >/dev/null
+    exit 0
+  else
+    echo "PASSED"
+    exit 0
+  fi
+fi
+
+# Fallback: Check for file changes in git (backward compatibility)
+FILES_CREATED=$(git status --short 2>/dev/null | grep -E "^(A|M|\?\?)" | wc -l)
+
+if [ "$FILES_CREATED" -eq 0 ]; then
+  echo "FAILED"
+  exit 0
+else
+  echo "PASSED"
+  exit 0
+fi