claude-flow-novice 2.15.0 → 2.15.2

package/.claude/skills/cfn-loop-orchestration/orchestrate.sh

@@ -469,25 +469,54 @@ function spawn_loop3_agents() {
     safe_task_id=$(sanitize_input "$task_id") || continue
     safe_agent_id=$(sanitize_input "$UNIQUE_AGENT_ID") || continue
 
-    # Spawn agent in background with process instrumentation and memory limits
-    if command -v execute_instrumented >/dev/null 2>&1; then
-        execute_instrumented "npx" "$CFN_VALIDATION_TIMEOUT" "$CFN_MEMORY_LIMIT" \
-          claude-flow-novice agent "$safe_agent_type" \
-          --task-id "$safe_task_id" \
-          --agent-id "$safe_agent_id" \
-          --iteration "$iteration" \
-          --context "$(build_agent_context "$safe_task_id" "$iteration" "$safe_agent_type" "" "loop3")" &
+    # Dual-mode agent spawning: Docker or CLI
+    # Docker mode: CFN_DOCKER_MODE=true or Docker socket available
+    # CLI mode: Default (uses npx)
+    if [[ "${CFN_DOCKER_MODE:-false}" == "true" ]] || [[ -S /var/run/docker.sock ]]; then
+        # Docker-based spawning (prevents WebAssembly OOM)
+        echo "  → Docker mode: spawning via container" >&2
+
+        docker run --detach \
+          --name "agent-${safe_agent_id}" \
+          --memory "${CFN_MEMORY_LIMIT:-2g}" \
+          --cpus 1.5 \
+          --network "${CFN_DOCKER_NETWORK:-mcp-network}" \
+          --env REDIS_URL=redis://redis:6379 \
+          --env AGENT_ID="${safe_agent_id}" \
+          --env AGENT_TYPE="${safe_agent_type}" \
+          --env TASK_ID="${safe_task_id}" \
+          --env ITERATION="${iteration}" \
+          --volume "${PROJECT_ROOT}/.claude:/app/.claude:ro" \
+          --volume "${PROJECT_ROOT}/packages:/app/packages" \
+          --volume "/tmp/agent-workspace-${safe_agent_id}:/app/workspace" \
+          "${CFN_DOCKER_IMAGE:-claude-flow-novice:agent}" \
+          sh -c "npx claude-flow-novice agent \"${safe_agent_type}\" --task-id \"${safe_task_id}\" --agent-id \"${safe_agent_id}\" --iteration \"${iteration}\"" >/dev/null 2>&1 &
+
+        AGENT_PID=$!
     else
-        # Fallback to raw spawn if instrumentation unavailable
-        npx claude-flow-novice agent "$safe_agent_type" \
-          --task-id "$safe_task_id" \
-          --agent-id "$safe_agent_id" \
-          --iteration "$iteration" \
-          --context "$(build_agent_context "$safe_task_id" "$iteration" "$safe_agent_type" "" "loop3")" &
+        # CLI-based spawning (traditional approach)
+        echo "  → CLI mode: spawning via npx" >&2
+
+        if command -v execute_instrumented >/dev/null 2>&1; then
+            execute_instrumented "npx" "$CFN_VALIDATION_TIMEOUT" "$CFN_MEMORY_LIMIT" \
+              claude-flow-novice agent "$safe_agent_type" \
+              --task-id "$safe_task_id" \
+              --agent-id "$safe_agent_id" \
+              --iteration "$iteration" \
+              --context "$(build_agent_context "$safe_task_id" "$iteration" "$safe_agent_type" "" "loop3")" &
+        else
+            # Fallback to raw spawn if instrumentation unavailable
+            npx claude-flow-novice agent "$safe_agent_type" \
+              --task-id "$safe_task_id" \
+              --agent-id "$safe_agent_id" \
+              --iteration "$iteration" \
+              --context "$(build_agent_context "$safe_task_id" "$iteration" "$safe_agent_type" "" "loop3")" &
+        fi
+
+        AGENT_PID=$!
     fi
 
     # Store PID for monitoring using unique agent ID
-    AGENT_PID=$!
     "$REDIS_COORD_SKILL/store-context.sh" \
       --task-id "$task_id" \
       --key "${UNIQUE_AGENT_ID}:pid" \
@@ -506,7 +535,7 @@ function spawn_loop3_agents() {
     fi
 
     # Store agent ID mapping for later retrieval using Redis SADD for set storage
-    redis-cli SADD "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" "$UNIQUE_AGENT_ID" >/dev/null
+    redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SADD "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" "$UNIQUE_AGENT_ID" >/dev/null
   done
 
   echo "[Loop 3] All agents spawned"
@@ -523,7 +552,7 @@ function wait_for_agents() {
 
   # Retrieve actual agent IDs from Redis (stored during spawn using SADD)
   local stored_ids
-  stored_ids=$(redis-cli SMEMBERS "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+  stored_ids=$(redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SMEMBERS "swarm:${task_id}:loop3:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
 
   # If stored IDs exist, use them; otherwise fallback to generating from agent types
   local -a AGENT_IDS
@@ -562,7 +591,7 @@ function wait_for_agents() {
     # Spawn BLPOP in background, write result to temp file
     (
       local result
-      if redis-cli blpop "swarm:${task_id}:${unique_agent_id}:done" "$timeout" >/dev/null 2>&1; then
+      if redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" blpop "swarm:${task_id}:${unique_agent_id}:done" "$timeout" >/dev/null 2>&1; then
         echo "success" > "$temp_file"
       else
         echo "timeout" > "$temp_file"
@@ -631,7 +660,7 @@ function wait_for_loop2_agents() {
 
   # Retrieve actual agent IDs from Redis (stored during spawn using SADD)
   local stored_ids
-  stored_ids=$(redis-cli SMEMBERS "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+  stored_ids=$(redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SMEMBERS "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
 
   # If stored IDs exist, use them; otherwise fallback to generating from agent types
   local -a VALIDATOR_IDS
@@ -665,7 +694,7 @@ function wait_for_loop2_agents() {
 
     # Spawn BLPOP in background
     (
-      if redis-cli blpop "swarm:${task_id}:${unique_validator_id}:done" "$timeout" >/dev/null 2>&1; then
+      if redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" blpop "swarm:${task_id}:${unique_validator_id}:done" "$timeout" >/dev/null 2>&1; then
         echo "success" > "$temp_file"
       else
         echo "timeout" > "$temp_file"
@@ -759,7 +788,7 @@ function spawn_loop2_agents() {
       --namespace "swarm" >/dev/null
 
     # Store agent ID mapping for later retrieval using Redis SADD for set storage
-    redis-cli SADD "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" "$UNIQUE_VALIDATOR_ID" >/dev/null
+    redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SADD "swarm:${task_id}:loop2:agent_ids:iteration${iteration}" "$UNIQUE_VALIDATOR_ID" >/dev/null
   done
 
   echo "[Loop 2] All agents spawned"
@@ -879,7 +908,7 @@ for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
 
   # Step 4: Gate check (Loop 3 self-validation)
   # Retrieve actual Loop 3 agent IDs for validation
-  LOOP3_IDS=$(redis-cli SMEMBERS "swarm:${TASK_ID}:loop3:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+  LOOP3_IDS=$(redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SMEMBERS "swarm:${TASK_ID}:loop3:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
 
   if [ -z "$LOOP3_IDS" ]; then
     echo "⚠️  WARNING: No Loop 3 agent IDs found in Redis, using agent types as fallback"
@@ -915,7 +944,7 @@ for ((ITERATION=1; ITERATION<=MAX_ITERATIONS; ITERATION++)); do
 
   # Step 7: Consensus check (Loop 2 validation)
   # Retrieve actual Loop 2 agent IDs for validation
-  LOOP2_IDS=$(redis-cli SMEMBERS "swarm:${TASK_ID}:loop2:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
+  LOOP2_IDS=$(redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SMEMBERS "swarm:${TASK_ID}:loop2:agent_ids:iteration${ITERATION}" 2>/dev/null | tr '\n' ',' | sed 's/,$//')
 
   if [ -z "$LOOP2_IDS" ]; then
     echo "⚠️  WARNING: No Loop 2 agent IDs found in Redis, using agent types as fallback"

package/.claude/skills/cfn-redis-coordination/complete-swarm.sh

@@ -53,7 +53,7 @@ fi
 METADATA_KEY="swarm:${SWARM_ID}:metadata"
 
 # Check if swarm exists
-if ! redis-cli exists "$METADATA_KEY" | grep -q "1"; then
+if ! redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" exists "$METADATA_KEY" | grep -q "1"; then
   echo "Error: Swarm not found: $SWARM_ID"
   exit 1
 fi
@@ -61,14 +61,14 @@ fi
 echo "[Swarm] Completing swarm: $SWARM_ID"
 
 # Update status
-redis-cli hset "$METADATA_KEY" \
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" hset "$METADATA_KEY" \
   status "completed" \
   completed_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
 
 # Add final metrics
 for KEY in "${!FINAL_METRICS[@]}"; do
   VALUE="${FINAL_METRICS[$KEY]}"
-  redis-cli hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
+  redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" hset "$METADATA_KEY" "$KEY" "$VALUE" > /dev/null
   echo "[Swarm] Stored metric: $KEY = $VALUE"
 done
 

package/.claude/skills/cfn-redis-coordination/redis-cli-wrapper.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Wrapper for redis-cli that enforces environment variable usage
+# This ensures all Redis commands use REDIS_HOST/REDIS_PORT instead of hardcoded localhost:6379
+set -euo pipefail
+
+REDIS_HOST="${REDIS_HOST:-localhost}"
+REDIS_PORT="${REDIS_PORT:-6379}"
+
+exec redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" "$@"

package/.claude/skills/cfn-redis-coordination/report-completion.sh

@@ -66,31 +66,31 @@ if ! awk -v conf="$CONFIDENCE" 'BEGIN { if (conf < 0 || conf > 1) exit 1 }'; the
 fi
 
 # Step 1: Signal completion (LPUSH for BLPOP coordination)
-redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" > /dev/null
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" > /dev/null
 
 # Step 2: Store confidence score (STRING key for fast access)
-redis-cli SET "swarm:${TASK_ID}:${AGENT_ID}:confidence" "$CONFIDENCE" EX 3600 > /dev/null
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" SET "swarm:${TASK_ID}:${AGENT_ID}:confidence" "$CONFIDENCE" EX 3600 > /dev/null
 
 # Step 3: Store result in hash (structured data)
 if [ -n "$RESULT" ]; then
-    redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
+    redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
         "confidence" "$CONFIDENCE" \
         "iteration" "$ITERATION" \
         "result" "$RESULT" \
         "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
 else
-    redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
+    redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" HSET "swarm:${TASK_ID}:${AGENT_ID}:result" \
         "confidence" "$CONFIDENCE" \
         "iteration" "$ITERATION" \
         "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > /dev/null
 fi
 
 # Step 4: Add to agent completion list (for orchestrator tracking)
-redis-cli LPUSH "swarm:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" LPUSH "swarm:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
 
 # Set TTL on hash
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
 
 echo "✅ Reported completion for agent: $AGENT_ID (confidence: $CONFIDENCE)"
 exit 0

package/claude-assets/agents/cfn-dev-team/architecture/api-designer-persona.md

@@ -9,6 +9,8 @@ weight: 0.333
 validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
+---
+
 # API Designer Persona - Loop 0.5 Design Consensus
 
 ## Role Identity

package/claude-assets/agents/cfn-dev-team/architecture/goal-planner.md

@@ -15,6 +15,8 @@ validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
 
+---
+
 # Goal Planner Agent: Strategic GOAP Planning
 
 ## 🚨 MANDATORY POST-EDIT VALIDATION

package/claude-assets/agents/cfn-dev-team/architecture/planner.md

@@ -16,6 +16,8 @@ validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
   - blocking-coordination-validator
+---
+
 # Strategic Planning Agent
 
 You are a Strategic Planning Agent responsible for breaking down complex tasks, coordinating cross-agent planning, and creating actionable execution plans.

package/claude-assets/agents/cfn-dev-team/architecture/system-architect.md

@@ -15,6 +15,8 @@ validation_hooks:
   - cfn-loop-memory-validator
   - test-coverage-validator
 
+---
+
 # System Architect Agent
 
 **Focus on enterprise system design, technical leadership, and architectural excellence without coordination dependencies.**