claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/process-lifecycle/process-manager.sh

@@ -1,144 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Process Lifecycle Advanced Management Script
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-CONFIG_PATH="${SCRIPT_DIR}/config.json"
-REDIS_CHANNEL="process-lifecycle"
-LOG_DIR="/var/log/claude-flow/processes"
-TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
-
-# Create log directory
-mkdir -p "$LOG_DIR"
-
-# Logging function with multiple verbosity levels
-log() {
-    local level="$1"
-    local message="$2"
-    local log_file="${LOG_DIR}/${level,,}_${TIMESTAMP}.log"
-    local color=""
-
-    case "$level" in
-        ERROR)   color="\e[31m" ;; # Red
-        WARN)    color="\e[33m" ;; # Yellow
-        INFO)    color="\e[34m" ;; # Blue
-        DEBUG)   color="\e[37m" ;; # White
-        *)       color="\e[0m"  ;; # Default
-    esac
-
-    # Log to file and stderr with color
-    echo -e "[${color}${level^^}\e[0m] $(date -Iseconds) - $message" | tee -a "$log_file" >&2
-}
-
-# Environment configuration and defaults
-PROCESS_ID="${PROCESS_ID:-}"
-ACTION="${1:-}"
-VERBOSE="${VERBOSE:-false}"
-
-# Configuration and validation
-load_config() {
-    if [[ ! -f "$CONFIG_PATH" ]]; then
-        log "ERROR" "Configuration file not found: $CONFIG_PATH"
-        exit 1
-    fi
-    jq -c '.' "$CONFIG_PATH"
-}
-
-validate_process() {
-    local process_id="$1"
-    jq -e --arg process "$process_id" \
-        '.processTypes[$process]' "$CONFIG_PATH" > /dev/null 2>&1
-}
-
-# Advanced process management functions
-start_process() {
-    local process_id="$1"
-
-    if ! validate_process "$process_id"; then
-        log "ERROR" "Invalid process type: $process_id"
-        return 1
-    fi
-
-    # Dependency validation
-    local dependencies=$(jq -r --arg process "$process_id" \
-        '.processTypes[$process].dependencies[]' "$CONFIG_PATH")
-
-    for dep in $dependencies; do
-        if ! systemctl is-active "$dep" &>/dev/null; then
-            log "WARN" "Dependency $dep not running, cannot start $process_id"
-            return 1
-        fi
-    done
-
-    log "INFO" "Starting process: $process_id"
-
-    # Placeholder for actual process start
-    # Would be replaced with actual process management logic
-    npx redis-cli PUBLISH "$REDIS_CHANNEL" \
-        "$(jq -n \
-            --arg process "$process_id" \
-            --arg action "start" \
-            '{process: $process, action: $action, timestamp: now}')"
-}
-
-stop_process() {
-    local process_id="$1"
-
-    # Check for dependent processes
-    local dependent_processes=$(jq -r \
-        --arg process "$process_id" \
-        '.processTypes | to_entries[] | select(.value.dependencies[] == $process) | .key' \
-        "$CONFIG_PATH")
-
-    for dep in $dependent_processes; do
-        if systemctl is-active "$dep" &>/dev/null; then
-            log "WARN" "Cannot stop $process_id, dependent process $dep is running"
-            return 1
-        fi
-    done
-
-    log "INFO" "Stopping process: $process_id"
-
-    npx redis-cli PUBLISH "$REDIS_CHANNEL" \
-        "$(jq -n \
-            --arg process "$process_id" \
-            --arg action "stop" \
-            '{process: $process, action: $action, timestamp: now}')"
-}
-
-# Main CLI router with enhanced error handling
-main() {
-    # Validate inputs
-    if [[ -z "$PROCESS_ID" ]]; then
-        log "ERROR" "PROCESS_ID must be specified"
-        exit 1
-    }
-
-    case "$ACTION" in
-        start)
-            start_process "$PROCESS_ID"
-            ;;
-        stop)
-            stop_process "$PROCESS_ID"
-            ;;
-        restart)
-            stop_process "$PROCESS_ID"
-            start_process "$PROCESS_ID"
-            ;;
-        status)
-            systemctl is-active "$PROCESS_ID" &>/dev/null &&
-                echo "RUNNING" ||
-                echo "STOPPED"
-            ;;
-        *)
-            log "ERROR" "Invalid action. Use: start|stop|restart|status"
-            exit 1
-            ;;
-    esac
-}
-
-# Enable verbose mode if requested
-$VERBOSE && set -x
-
-# Execute main function
-main "$@"

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

@@ -1,332 +0,0 @@
-# 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

@@ -1,176 +0,0 @@
-#!/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

@@ -1,66 +0,0 @@
-#!/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