claude-flow-novice 2.8.1 → 2.9.0

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

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

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

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

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

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

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

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