claude-flow-novice 2.6.0 → 2.8.1

package/.claude/skills/cfn-loop-orchestration/helpers/auto-tune-timeouts.sh

@@ -0,0 +1,228 @@
+#!/bin/bash
+#
+# Auto-Tune Timeouts Helper
+#
+# Dynamically calculates optimal timeouts for CFN Loop agents based on:
+# - Historical performance data
+# - Agent type (implementer vs validator)
+# - Task complexity
+# - Current system load
+#
+# Usage:
+#   auto-tune-timeouts.sh --agent-type <type> --task-complexity <low|medium|high> [--history-file <file>]
+#
+# Returns: Recommended timeout in seconds
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Default configuration
+DEFAULT_TIMEOUT=300
+MIN_TIMEOUT=60
+MAX_TIMEOUT=1800
+HISTORY_FILE="/tmp/cfn-agent-performance-history.json"
+
+# Baseline timeouts by agent type (seconds)
+declare -A BASELINE_TIMEOUTS=(
+  ["implementer"]=300
+  ["validator"]=180
+  ["coordinator"]=600
+  ["product-owner"]=120
+)
+
+# Complexity multipliers
+declare -A COMPLEXITY_MULTIPLIERS=(
+  ["low"]=0.7
+  ["medium"]=1.0
+  ["high"]=1.5
+)
+
+# Parse arguments
+AGENT_TYPE=""
+TASK_COMPLEXITY="medium"
+CUSTOM_HISTORY_FILE=""
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --agent-type)
+      AGENT_TYPE="$2"
+      shift 2
+      ;;
+    --task-complexity)
+      TASK_COMPLEXITY="$2"
+      shift 2
+      ;;
+    --history-file)
+      CUSTOM_HISTORY_FILE="$2"
+      shift 2
+      ;;
+    --help)
+      echo "Usage: auto-tune-timeouts.sh --agent-type <type> --task-complexity <low|medium|high> [--history-file <file>]"
+      echo ""
+      echo "Agent Types: implementer, validator, coordinator, product-owner"
+      echo "Task Complexity: low, medium, high"
+      echo ""
+      echo "Returns: Recommended timeout in seconds"
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validation
+if [ -z "$AGENT_TYPE" ]; then
+  echo "Error: --agent-type is required"
+  exit 1
+fi
+
+if [[ ! "${BASELINE_TIMEOUTS[$AGENT_TYPE]+isset}" ]]; then
+  echo "Error: Unknown agent type '$AGENT_TYPE'"
+  echo "Valid types: ${!BASELINE_TIMEOUTS[@]}"
+  exit 1
+fi
+
+if [[ ! "${COMPLEXITY_MULTIPLIERS[$TASK_COMPLEXITY]+isset}" ]]; then
+  echo "Error: Unknown task complexity '$TASK_COMPLEXITY'"
+  echo "Valid complexities: ${!COMPLEXITY_MULTIPLIERS[@]}"
+  exit 1
+fi
+
+# Use custom history file if provided
+if [ -n "$CUSTOM_HISTORY_FILE" ]; then
+  HISTORY_FILE="$CUSTOM_HISTORY_FILE"
+fi
+
+# Function to get historical average execution time
+get_historical_avg() {
+  local agent_type=$1
+
+  if [ ! -f "$HISTORY_FILE" ]; then
+    echo "$DEFAULT_TIMEOUT"
+    return
+  fi
+
+  # Extract average execution time for this agent type
+  local avg_time=$(jq -r --arg type "$agent_type" \
+    '.history[]
+    | select(.agentType == $type)
+    | .executionTime
+    | select(. != null)' "$HISTORY_FILE" 2>/dev/null | \
+    awk '{ sum += $1; count++ } END { if (count > 0) print sum/count; else print 0 }')
+
+  if [ -z "$avg_time" ] || [ "$avg_time" = "0" ]; then
+    echo "$DEFAULT_TIMEOUT"
+  else
+    echo "$avg_time"
+  fi
+}
+
+# Function to get system load factor
+get_load_factor() {
+  # Check if on Linux
+  if [ -f /proc/loadavg ]; then
+    local load_1min=$(cat /proc/loadavg | awk '{print $1}')
+    local cpu_count=$(nproc 2>/dev/null || echo 1)
+
+    # Calculate load factor (load per CPU)
+    local load_factor=$(echo "scale=2; $load_1min / $cpu_count" | bc)
+
+    # Return multiplier (1.0 baseline, increase if high load)
+    if (( $(echo "$load_factor > 2.0" | bc -l) )); then
+      echo "1.5"  # High load, increase timeout by 50%
+    elif (( $(echo "$load_factor > 1.0" | bc -l) )); then
+      echo "1.2"  # Moderate load, increase timeout by 20%
+    else
+      echo "1.0"  # Normal load
+    fi
+  else
+    # Non-Linux or can't determine load
+    echo "1.0"
+  fi
+}
+
+# Function to get Redis latency factor
+get_redis_latency_factor() {
+  # Measure Redis ping latency
+  local start_ns=$(date +%s%N)
+  redis-cli PING >/dev/null 2>&1 || return
+  local end_ns=$(date +%s%N)
+
+  local latency_ns=$((end_ns - start_ns))
+  local latency_ms=$(echo "scale=2; $latency_ns / 1000000" | bc)
+
+  # If Redis is slow, increase timeout
+  if (( $(echo "$latency_ms > 100" | bc -l) )); then
+    echo "1.3"  # Very slow Redis, increase timeout by 30%
+  elif (( $(echo "$latency_ms > 50" | bc -l) )); then
+    echo "1.1"  # Slow Redis, increase timeout by 10%
+  else
+    echo "1.0"  # Normal Redis performance
+  fi
+}
+
+# Calculate base timeout
+baseline_timeout=${BASELINE_TIMEOUTS[$AGENT_TYPE]}
+
+# Get historical average
+historical_avg=$(get_historical_avg "$AGENT_TYPE")
+
+# If we have historical data, use weighted average
+if [ "$historical_avg" != "$DEFAULT_TIMEOUT" ]; then
+  # 70% historical, 30% baseline
+  base_timeout=$(echo "scale=0; ($historical_avg * 0.7) + ($baseline_timeout * 0.3)" | bc)
+else
+  base_timeout=$baseline_timeout
+fi
+
+# Apply complexity multiplier
+complexity_multiplier=${COMPLEXITY_MULTIPLIERS[$TASK_COMPLEXITY]}
+timeout_after_complexity=$(echo "scale=0; $base_timeout * $complexity_multiplier" | bc)
+
+# Apply system load factor
+load_factor=$(get_load_factor)
+timeout_after_load=$(echo "scale=0; $timeout_after_complexity * $load_factor" | bc)
+
+# Apply Redis latency factor
+redis_factor=$(get_redis_latency_factor)
+final_timeout=$(echo "scale=0; $timeout_after_load * $redis_factor" | bc)
+
+# Ensure timeout is within bounds
+if (( $(echo "$final_timeout < $MIN_TIMEOUT" | bc -l) )); then
+  final_timeout=$MIN_TIMEOUT
+fi
+
+if (( $(echo "$final_timeout > $MAX_TIMEOUT" | bc -l) )); then
+  final_timeout=$MAX_TIMEOUT
+fi
+
+# Round to integer
+final_timeout=$(printf "%.0f" "$final_timeout")
+
+# Output result (JSON format for easy parsing)
+cat <<EOF
+{
+  "agentType": "$AGENT_TYPE",
+  "taskComplexity": "$TASK_COMPLEXITY",
+  "recommendedTimeout": $final_timeout,
+  "calculation": {
+    "baselineTimeout": $baseline_timeout,
+    "historicalAverage": $historical_avg,
+    "complexityMultiplier": $complexity_multiplier,
+    "loadFactor": $load_factor,
+    "redisLatencyFactor": $redis_factor
+  },
+  "bounds": {
+    "min": $MIN_TIMEOUT,
+    "max": $MAX_TIMEOUT
+  }
+}
+EOF
+
+# Also output just the timeout value to stderr for easy shell capture
+echo "$final_timeout" >&2
+
+exit 0

package/.claude/skills/cfn-loop-orchestration/helpers/consensus.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Consensus Checker
+# Collects and validates Loop 2 consensus scores
+#
+# Usage:
+#   consensus.sh --task-id <id> \
+#                --agents <agent1,agent2,...> \
+#                --threshold <0.0-1.0> \
+#                --min-quorum <n|n%|0.n>
+#
+# Returns:
+#   Exit 0: Consensus reached
+#   Exit 1: Consensus failed
+##############################################################################
+
+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 consensus scores
+SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+REDIS_COORD_SKILL="$SKILL_DIR/redis-coordination"
+
+echo "Consensus Check Configuration:"
+echo "  Task ID: $TASK_ID"
+echo "  Agent IDs: $AGENTS"
+echo "  Min Quorum: $MIN_QUORUM"
+echo ""
+
+# Collect Loop 2 consensus scores
+CONSENSUS=$("$REDIS_COORD_SKILL/invoke-waiting-mode.sh" collect \
+  --task-id "$TASK_ID" \
+  --agent-ids "$AGENTS" \
+  --min-quorum "$MIN_QUORUM" 2>&1) || {
+  echo "❌ Error: Failed to collect Loop 2 consensus 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 2 Consensus Check:"
+echo "  Consensus: $CONSENSUS"
+echo "  Threshold: $THRESHOLD"
+echo "  Required: >= $THRESHOLD"
+
+# Compare consensus to threshold
+if (( $(echo "$CONSENSUS >= $THRESHOLD" | bc -l) )); then
+  echo "✅ Consensus REACHED - Loop 2 validation successful"
+  exit 0
+else
+  echo "❌ Consensus FAILED - Iteration required"
+  echo "   Gap: $(echo "$THRESHOLD - $CONSENSUS" | bc -l)"
+  exit 1
+fi

package/.claude/skills/cfn-loop-orchestration/helpers/deliverable-verifier.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Deliverable Verifier
+# Verifies expected deliverables were created (prevents "consensus on vapor")
+#
+# Usage:
+#   deliverable-verifier.sh --expected-files <file1,file2,...> \
+#                           --task-type <keyword-detection>
+#
+# Returns:
+#   Exit 0: Deliverables verified
+#   Exit 1: Missing deliverables
+##############################################################################
+
+set -euo pipefail
+
+# Parameters
+EXPECTED_FILES=""
+TASK_TYPE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --expected-files) EXPECTED_FILES="$2"; shift 2 ;;
+    --task-type) TASK_TYPE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; exit 1 ;;
+  esac
+done
+
+# Check git status for file changes
+GIT_CHANGES=$(git status --short | wc -l)
+
+echo "Deliverable Verification:"
+echo "  Git changes detected: $GIT_CHANGES files"
+
+# If expected files specified, check them explicitly
+if [ -n "$EXPECTED_FILES" ]; then
+  IFS=',' read -ra FILE_ARRAY <<< "$EXPECTED_FILES"
+  MISSING_COUNT=0
+
+  for file in "${FILE_ARRAY[@]}"; do
+    if [ -f "$file" ]; then
+      echo "  ✅ Found: $file"
+    else
+      echo "  ❌ Missing: $file"
+      MISSING_COUNT=$((MISSING_COUNT + 1))
+    fi
+  done
+
+  if [ $MISSING_COUNT -gt 0 ]; then
+    echo "❌ Deliverable verification FAILED: $MISSING_COUNT missing files"
+    exit 1
+  fi
+fi
+
+# Keyword-based task type detection
+if [ -n "$TASK_TYPE" ]; then
+  if [[ "$TASK_TYPE" =~ (create|build|implement|add|generate) ]]; then
+    # Implementation tasks require file changes
+    if [ $GIT_CHANGES -eq 0 ]; then
+      echo "❌ Implementation task detected but no files created"
+      echo "   Task type: $TASK_TYPE"
+      echo "   This is 'consensus on vapor' - forcing iteration"
+      exit 1
+    fi
+  fi
+fi
+
+echo "✅ Deliverable verification PASSED"
+exit 0

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