claude-flow-novice 2.9.1 → 2.10.0

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]}")/.claude/skills/cfn-cfn-.." && 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/spawn-agents.sh

@@ -0,0 +1,271 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Agent Spawning Helper with Context Injection - ACE System Phase 1.4
+# Spawns Loop 3 agents with enriched historical context from Redis
+#
+# Usage:
+#   ./spawn-agents.sh --task-id TASK_ID --iteration N --agents AGENTS --original-context '{...}'
+#
+# Arguments:
+#   --task-id           Unique task identifier (required)
+#   --iteration         Current iteration number (required)
+#   --agents            Comma-separated list of agent types (required)
+#   --original-context  Original task context string (required)
+#
+# Output:
+#   Spawns agents in background with enriched context
+#   Returns: 0 on success, 1 on failure
+#   Logs to: .artifacts/logs/spawn-agents-{TASK_ID}.log
+#
+# Performance:
+#   - Target injection overhead: < 200ms per agent
+#   - Graceful fallback to original context on injection failure
+##############################################################################
+
+set -euo pipefail
+
+# Script directory and project root
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
+
+# Default values
+TASK_ID=""
+ITERATION=""
+AGENTS=""
+ORIGINAL_CONTEXT=""
+LOG_DIR="$PROJECT_ROOT/.artifacts/logs"
+REDIS_COORD_SKILL="$PROJECT_ROOT/.claude/skills/cfn-redis-coordination"
+
+# Ensure log directory exists
+mkdir -p "$LOG_DIR"
+
+##############################################################################
+# Logging Functions
+##############################################################################
+
+log_info() {
+  local message="$1"
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
+}
+
+log_warn() {
+  local message="$1"
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [WARN] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
+}
+
+log_error() {
+  local message="$1"
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] $message" | tee -a "$LOG_DIR/spawn-agents-${TASK_ID}.log"
+}
+
+##############################################################################
+# Helper Functions
+##############################################################################
+
+sanitize_input() {
+  local input="$1"
+  # Remove dangerous characters (only allow alphanumeric, dash, underscore, dot, comma, colon)
+  echo "$input" | sed 's/[^a-zA-Z0-9._:,-]//g'
+}
+
+enrich_context_for_agent() {
+  local task_id="$1"
+  local agent_type="$2"
+  local original_context="$3"
+
+  # Measure injection time
+  local start_time=$(date +%s%3N)
+
+  # Call context-injection.sh
+  local enriched_context
+  enriched_context=$("$SCRIPT_DIR/context-injection.sh" \
+    --task-id "$task_id" \
+    --agent-type "$agent_type" \
+    --original-context "$original_context" 2>&1)
+
+  local exit_code=$?
+  local end_time=$(date +%s%3N)
+  local duration=$((end_time - start_time))
+
+  # Check if injection succeeded
+  if [ $exit_code -eq 0 ] && echo "$enriched_context" | jq . >/dev/null 2>&1; then
+    # Validate JSON structure
+    if echo "$enriched_context" | jq -e '.historical_context' >/dev/null 2>&1; then
+      log_info "Context injection successful for $agent_type: ${duration}ms"
+
+      # Log context size
+      local hist_size=$(echo "$enriched_context" | jq -r '.historical_context' | wc -c)
+      log_injection_metrics "$agent_type" "$duration" "$hist_size"
+
+      # Warn if injection is slow
+      if [ "$duration" -gt 200 ]; then
+        log_warn "Context injection exceeded 200ms threshold: ${duration}ms"
+      fi
+
+      echo "$enriched_context"
+      return 0
+    fi
+  fi
+
+  # Injection failed - log and return original context
+  log_warn "Context injection failed for $agent_type, using original context"
+  echo "$original_context"
+  return 1
+}
+
+log_injection_metrics() {
+  local agent="$1"
+  local duration_ms="$2"
+  local context_size="$3"
+
+  log_info "Agent $agent metrics: injection ${duration_ms}ms, historical ${context_size} chars"
+}
+
+##############################################################################
+# Main Spawning Function
+##############################################################################
+
+spawn_agents_with_context() {
+  local task_id="$1"
+  local iteration="$2"
+  local agents="$3"
+  local original_context="$4"
+
+  log_info "Starting agent spawning with context injection"
+  log_info "Task ID: $task_id, Iteration: $iteration"
+
+  # Convert comma-separated agents to array
+  IFS=',' read -ra AGENT_ARRAY <<< "$agents"
+
+  # Track agent instance counts for unique ID generation
+  declare -A AGENT_INSTANCE_COUNTS
+
+  # Spawn each agent
+  local spawned_count=0
+  local injection_success_count=0
+
+  for agent_type in "${AGENT_ARRAY[@]}"; do
+    # Trim whitespace
+    agent_type=$(echo "$agent_type" | xargs)
+
+    # Generate unique agent ID (agent-type-iteration-instance)
+    AGENT_INSTANCE_COUNTS["$agent_type"]=$((${AGENT_INSTANCE_COUNTS["$agent_type"]:-0} + 1))
+    INSTANCE_NUM="${AGENT_INSTANCE_COUNTS["$agent_type"]}"
+    UNIQUE_AGENT_ID="${agent_type}-${iteration}-${INSTANCE_NUM}"
+
+    log_info "Spawning agent: $agent_type (ID: $UNIQUE_AGENT_ID)"
+
+    # Sanitize inputs
+    local safe_agent_type safe_task_id safe_agent_id
+    safe_agent_type=$(sanitize_input "$agent_type") || {
+      log_error "Failed to sanitize agent type: $agent_type"
+      continue
+    }
+    safe_task_id=$(sanitize_input "$task_id") || {
+      log_error "Failed to sanitize task ID: $task_id"
+      continue
+    }
+    safe_agent_id=$(sanitize_input "$UNIQUE_AGENT_ID") || {
+      log_error "Failed to sanitize agent ID: $UNIQUE_AGENT_ID"
+      continue
+    }
+
+    # Enrich context with historical data
+    local context_to_use
+    context_to_use=$(enrich_context_for_agent "$safe_task_id" "$safe_agent_type" "$original_context")
+    local injection_status=$?
+
+    if [ $injection_status -eq 0 ]; then
+      ((injection_success_count++))
+    fi
+
+    # Spawn agent in background with enriched context
+    npx claude-flow-novice agent "$safe_agent_type" \
+      --task-id "$safe_task_id" \
+      --agent-id "$safe_agent_id" \
+      --iteration "$iteration" \
+      --context "$context_to_use" &
+
+    # Store PID for monitoring
+    AGENT_PID=$!
+    "$REDIS_COORD_SKILL/store-context.sh" \
+      --task-id "$task_id" \
+      --key "${UNIQUE_AGENT_ID}:pid" \
+      --value "{\"pid\": $AGENT_PID}" \
+      --namespace "swarm" >/dev/null
+
+    # Store agent ID mapping for later retrieval
+    redis-cli SADD "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" "$UNIQUE_AGENT_ID" >/dev/null
+
+    log_info "Agent $safe_agent_type spawned (PID: $AGENT_PID)"
+    ((spawned_count++))
+  done
+
+  # Log summary
+  log_info "Agent spawning complete: $spawned_count agents spawned"
+  log_info "Context injection success rate: $injection_success_count/$spawned_count"
+
+  if [ "$spawned_count" -eq 0 ]; then
+    log_error "No agents were spawned"
+    return 1
+  fi
+
+  return 0
+}
+
+##############################################################################
+# Argument Parsing
+##############################################################################
+
+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
+        ;;
+      --original-context)
+        ORIGINAL_CONTEXT="$2"
+        shift 2
+        ;;
+      *)
+        echo "Unknown argument: $1"
+        exit 1
+        ;;
+    esac
+  done
+
+  # Validate required arguments
+  if [ -z "$TASK_ID" ] || [ -z "$ITERATION" ] || [ -z "$AGENTS" ] || [ -z "$ORIGINAL_CONTEXT" ]; then
+    echo "Error: Missing required arguments"
+    echo "Usage: $0 --task-id TASK_ID --iteration N --agents AGENTS --original-context CONTEXT"
+    exit 1
+  fi
+}
+
+##############################################################################
+# Main Execution
+##############################################################################
+
+main() {
+  parse_arguments "$@"
+
+  # Execute spawning with context injection
+  spawn_agents_with_context "$TASK_ID" "$ITERATION" "$AGENTS" "$ORIGINAL_CONTEXT"
+
+  exit $?
+}
+
+# Run main function if script is executed directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+  main "$@"
+fi

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