claude-flow-novice 2.5.2 → 2.8.1

package/.claude/skills/cfn-loop-orchestration/helpers/gate-check.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Gate Check Helper
+# Validates Loop 3 self-assessment against gate threshold
+#
+# Usage:
+#   gate-check.sh --task-id <id> \
+#                 --agents <agent1,agent2,...> \
+#                 --threshold <0.0-1.0> \
+#                 --min-quorum <n|n%|0.n>
+#
+# Returns:
+#   Exit 0: Gate passed (Loop 3 meets threshold)
+#   Exit 1: Gate failed (Loop 3 needs iteration)
+##############################################################################
+
+set -euo pipefail
+
+# Parameters
+TASK_ID=""
+AGENTS=""
+THRESHOLD=""
+MIN_QUORUM=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id) TASK_ID="$2"; shift 2 ;;
+    --agents) AGENTS="$2"; shift 2 ;;
+    --threshold) THRESHOLD="$2"; shift 2 ;;
+    --min-quorum) MIN_QUORUM="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ] || [ -z "$AGENTS" ] || [ -z "$THRESHOLD" ] || [ -z "$MIN_QUORUM" ]; then
+  echo "Error: Missing required parameters"
+  exit 1
+fi
+
+# Use Redis Coordination skill to collect confidence scores
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
+
+echo "Gate Check Configuration:"
+echo "  Task ID: $TASK_ID"
+echo "  Agent IDs: $AGENTS"
+echo "  Min Quorum: $MIN_QUORUM"
+echo ""
+
+# Collect Loop 3 confidence scores
+# Note: invoke-waiting-mode.sh outputs consensus to stdout and verbose messages to stderr
+# We capture only stdout to get the numeric consensus value
+CONSENSUS=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
+  --task-id "$TASK_ID" \
+  --agent-ids "$AGENTS" \
+  --min-quorum "$MIN_QUORUM") || {
+  echo "❌ Error: Failed to collect Loop 3 confidence scores"
+  echo "   Agent IDs: $AGENTS"
+  echo "   Output: $CONSENSUS"
+  exit 1
+}
+
+# Validate consensus is a valid number
+if ! [[ "$CONSENSUS" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+  echo "⚠️  WARNING: Invalid consensus value: $CONSENSUS (expected numeric)"
+  echo "   Defaulting to 0.0"
+  CONSENSUS="0.0"
+fi
+
+echo "Loop 3 Gate Check:"
+echo "  Consensus: $CONSENSUS"
+echo "  Threshold: $THRESHOLD"
+echo "  Required: >= $THRESHOLD"
+
+# Compare consensus to gate threshold
+if (( $(echo "$CONSENSUS >= $THRESHOLD" | bc -l) )); then
+  echo "✅ Gate PASSED - Loop 3 self-validation successful"
+
+  # NOTE: Orchestrator controls Loop 2 spawn timing directly (orchestrate.sh line 520)
+  # No signal broadcast needed - Loop 2 agents spawn after this helper returns 0
+
+  exit 0
+else
+  echo "❌ Gate FAILED - Loop 3 needs improvement"
+  echo "   Gap: $(echo "$THRESHOLD - $CONSENSUS" | bc -l)"
+  exit 1
+fi

package/.claude/skills/cfn-loop-orchestration/helpers/iteration-manager.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Iteration Manager
+# Manages iteration cycles and feedback injection
+#
+# Usage:
+#   iteration-manager.sh --task-id <id> \
+#                        --iteration <n> \
+#                        --agents <agent1,agent2,...> \
+#                        --feedback-source <redis-key-prefix>
+#
+# Returns:
+#   Exit 0: Agents awakened for next iteration
+#   Exit 1: Error during wake process
+##############################################################################
+
+set -euo pipefail
+
+# Parameters
+TASK_ID=""
+ITERATION=""
+AGENTS=""
+FEEDBACK_SOURCE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id) TASK_ID="$2"; shift 2 ;;
+    --iteration) ITERATION="$2"; shift 2 ;;
+    --agents) AGENTS="$2"; shift 2 ;;
+    --feedback-source) FEEDBACK_SOURCE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$TASK_ID" ] || [ -z "$ITERATION" ] || [ -z "$AGENTS" ]; then
+  echo "Error: Missing required parameters"
+  exit 1
+fi
+
+# Use Redis Coordination skill for wake operations
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
+
+echo "Starting Iteration $ITERATION"
+echo "Agents to wake: $AGENTS"
+
+# Convert comma-separated agents to array
+IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
+
+# Wake each agent with feedback
+for agent_id in "${AGENT_ARRAY[@]}"; do
+  # Retrieve agent-specific feedback if feedback source provided using Redis coordination primitive
+  FEEDBACK=""
+  if [ -n "$FEEDBACK_SOURCE" ]; then
+    # Retrieve context from Redis using primitive
+    FEEDBACK_JSON=$("$REDIS_COORD_SKILL/retrieve-context.sh" \
+      --task-id "$TASK_ID" \
+      --key "$agent_id" \
+      --namespace "$FEEDBACK_SOURCE" 2>/dev/null || echo "{}")
+
+    # Extract feedback message from JSON (try multiple field names)
+    FEEDBACK=$(echo "$FEEDBACK_JSON" | jq -r '.message // .feedback // .data // ""' 2>/dev/null || echo "")
+  fi
+
+  # Default feedback if none exists
+  if [ -z "$FEEDBACK" ]; then
+    FEEDBACK="Continue iteration $ITERATION with quality improvements"
+  fi
+
+  echo "Waking $agent_id with feedback: ${FEEDBACK:0:80}..."
+
+  # Wake agent using Redis Coordination skill
+  "$REDIS_COORD_SKILL/invoke-waiting-mode.sh" wake \
+    --task-id "$TASK_ID" \
+    --agent-id "$agent_id" \
+    --reason "cfn_loop_iteration" \
+    --iteration "$ITERATION" \
+    --feedback "$FEEDBACK" || {
+    echo "Warning: Failed to wake $agent_id"
+  }
+done
+
+echo "✅ All agents awakened for iteration $ITERATION"
+exit 0

package/.claude/skills/cfn-loop-orchestration/helpers/timeout-calculator.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Timeout Calculator
+# Calculates phase-specific timeouts for agent execution
+#
+# Usage:
+#   timeout-calculator.sh --phase-id <phase-identifier>
+#
+# Returns:
+#   Timeout value in seconds (stdout)
+##############################################################################
+
+set -euo pipefail
+
+# Parameters
+PHASE_ID=""
+DEFAULT_TIMEOUT=3600  # 60 minutes
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --phase-id) PHASE_ID="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; exit 1 ;;
+  esac
+done
+
+# Phase-specific timeout configuration
+# Based on empirical data from Sprint 6
+case "$PHASE_ID" in
+  phase-1)
+    # Backend work - relatively fast
+    echo 900  # 15 minutes
+    ;;
+  phase-2)
+    # React components - more complex
+    echo 3600  # 60 minutes
+    ;;
+  phase-3)
+    # Advanced components - complex
+    echo 3600  # 60 minutes
+    ;;
+  phase-4)
+    # Testing/integration - moderate
+    echo 1800  # 30 minutes
+    ;;
+  *)
+    # Unknown phase - use default
+    echo $DEFAULT_TIMEOUT
+    ;;
+esac

package/.claude/skills/cfn-loop-orchestration/inject-loop-context.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# inject-loop-context.sh - Inject loop-specific context into agent prompts
+
+set -euo pipefail
+
+LOOP_TYPE="$1"  # loop3, loop2, loop4, loop1
+AGENT_CONTEXT="$2"  # Original agent context
+
+# Use absolute path from current working directory
+PROJECT_ROOT="/mnt/c/Users/masha/Documents/claude-flow-novice"
+
+# Load base CFN Loop context
+BASE_CONTEXT_FILE="$PROJECT_ROOT/.claude/prompts/cfn-loop-context.md"
+if [[ ! -f "$BASE_CONTEXT_FILE" ]]; then
+  echo "ERROR: Base context file not found: $BASE_CONTEXT_FILE" >&2
+  exit 1
+fi
+BASE_CONTEXT=$(cat "$BASE_CONTEXT_FILE")
+
+# Load loop-specific context (optional)
+LOOP_CONTEXT_FILE="$PROJECT_ROOT/.claude/prompts/loop-specific/${LOOP_TYPE}.md"
+if [[ -f "$LOOP_CONTEXT_FILE" ]]; then
+  LOOP_CONTEXT=$(cat "$LOOP_CONTEXT_FILE")
+else
+  LOOP_CONTEXT=""
+fi
+
+# Combine contexts
+cat <<EOF
+$BASE_CONTEXT
+
+---
+
+$LOOP_CONTEXT
+
+---
+
+# Your Task
+
+$AGENT_CONTEXT
+EOF

package/.claude/skills/cfn-loop-orchestration/monitor-execution.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+
+# CFN Loop Execution Monitoring Script
+# Version: 1.0.0
+# Purpose: Real-time monitoring and metrics collection for CFN Loop orchestration
+
+set -euo pipefail
+
+# Logging and output configuration
+LOG_DIR="/tmp/cfn-loop-monitoring"
+TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
+METRICS_FILE="${LOG_DIR}/metrics_${TIMESTAMP}.json"
+
+# Dependency checks
+command -v redis-cli >/dev/null 2>&1 || {
+    echo "Error: redis-cli is required but not installed." >&2
+    exit 1
+}
+
+# Configuration and argument parsing
+TASK_ID=""
+EXPORT_PATH=""
+INTERVAL=5  # Default monitoring interval (seconds)
+TIMEOUT=3600  # Default timeout (1 hour)
+
+usage() {
+    echo "Usage: $0 --task-id <task_id> [--export <export_path>] [--interval <seconds>] [--timeout <seconds>]"
+    exit 1
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --task-id)
+            TASK_ID="$2"
+            shift 2
+            ;;
+        --export)
+            EXPORT_PATH="$2"
+            shift 2
+            ;;
+        --interval)
+            INTERVAL="$2"
+            shift 2
+            ;;
+        --timeout)
+            TIMEOUT="$2"
+            shift 2
+            ;;
+        *)
+            usage
+            ;;
+    esac
+done
+
+[[ -z "$TASK_ID" ]] && { echo "Error: task-id is required"; usage; }
+
+# Create log directory
+mkdir -p "$LOG_DIR"
+
+# Monitoring function
+monitor_cfn_loop() {
+    local start_time=$(date +%s)
+    local metrics=()
+    local current_iteration=1
+    local total_iterations=0
+    local gate_check_passed=false
+    local consensus_achieved=false
+
+    # Initialize metrics JSON structure
+    local metrics_json=$(jq -n \
+        --arg task_id "$TASK_ID" \
+        --arg start_time "$(date -Iseconds)" \
+        '{
+            task_id: $task_id,
+            start_time: $start_time,
+            iterations: [],
+            performance: {},
+            status: "in_progress"
+        }')
+
+    echo "Starting monitoring for CFN Loop Task ID: $TASK_ID"
+    echo "Monitoring interval: $INTERVAL seconds"
+    echo "Timeout: $TIMEOUT seconds"
+
+    while true; do
+        # Track iteration metrics
+        local iteration_start=$(date +%s)
+
+        # Check Loop 3 completion
+        local loop3_agents=$(redis-cli smembers "cfn_loop:${TASK_ID}:loop3_agents")
+        local loop3_completed=$(redis-cli scard "cfn_loop:${TASK_ID}:loop3_completed")
+        local loop3_total=$(echo "$loop3_agents" | wc -l)
+
+        # Check Gate Check
+        local gate_confidence=$(redis-cli get "cfn_loop:${TASK_ID}:gate_confidence")
+        if [[ -n "$gate_confidence" && $(echo "$gate_confidence >= 0.75" | bc) -eq 1 ]]; then
+            gate_check_passed=true
+            echo "✅ Gate Check Passed (Confidence: $gate_confidence)"
+        fi
+
+        # Check Loop 2 Consensus
+        local consensus_score=$(redis-cli get "cfn_loop:${TASK_ID}:consensus_score")
+        if [[ -n "$consensus_score" && $(echo "$consensus_score >= 0.90" | bc) -eq 1 ]]; then
+            consensus_achieved=true
+            echo "✅ Consensus Achieved (Score: $consensus_score)"
+        fi
+
+        # Collect performance metrics
+        local iteration_end=$(date +%s)
+        local iteration_duration=$((iteration_end - iteration_start))
+
+        # Update metrics JSON
+        metrics_json=$(echo "$metrics_json" | jq --arg iteration "$current_iteration" \
+            --arg duration "$iteration_duration" \
+            --arg loop3_completed "$loop3_completed" \
+            --arg loop3_total "$loop3_total" \
+            '.iterations += [{
+                number: $iteration,
+                duration: $duration,
+                loop3_completed: $loop3_completed,
+                loop3_total: $loop3_total
+            }]')
+
+        # Exit conditions
+        if [[ "$gate_check_passed" == "true" && "$consensus_achieved" == "true" ]]; then
+            metrics_json=$(echo "$metrics_json" | jq '.status = "success"')
+            break
+        fi
+
+        # Check for timeout
+        local current_time=$(date +%s)
+        local total_runtime=$((current_time - start_time))
+        if [[ $total_runtime -ge $TIMEOUT ]]; then
+            metrics_json=$(echo "$metrics_json" | jq '.status = "timeout"')
+            echo "❌ Monitoring timed out after $TIMEOUT seconds"
+            break
+        fi
+
+        current_iteration=$((current_iteration + 1))
+        sleep "$INTERVAL"
+    done
+
+    # Export metrics if export path provided
+    if [[ -n "$EXPORT_PATH" ]]; then
+        echo "$metrics_json" > "$EXPORT_PATH"
+        echo "Metrics exported to $EXPORT_PATH"
+    fi
+
+    # Final status report
+    local status=$(echo "$metrics_json" | jq -r '.status')
+    echo "CFN Loop Execution Monitoring Complete. Status: $status"
+}
+
+# Execute monitoring
+monitor_cfn_loop