claude-flow-novice 2.15.5 → 2.15.7

package/.claude/skills/cfn-redis-coordination/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "src/redis/**/*"]
+}

package/claude-assets/agents/cfn-dev-team/coordinators/cfn-frontend-coordinator.md

@@ -46,25 +46,18 @@ fi
 
 **Old (Deprecated):**
 ```bash
-redis-cli HSET "swarm:${TASK_ID}:confidence:iteration${ITERATION}" \
-  "${AGENT_ID}" "0.85"
-```
 
 **New (Required):**
 ```bash
 # Execute tests and capture output
 TEST_OUTPUT=$(npm test -- --reporter=json 2>&1)
 
-# Parse test results
-RESULTS=$(./.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh \
-  "jest" "$TEST_OUTPUT")
-
-# Store in Redis
-redis-cli HSET "swarm:${TASK_ID}:test-results:iteration${ITERATION}" \
-  "${AGENT_ID}" "$RESULTS"
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
 
-# Signal completion
-redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
 ```
 
 ## Core Responsibility
@@ -78,22 +71,10 @@ redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
 ### Frontend Context Storage in Redis
 ```bash
 # Store frontend coordination context
-redis-cli HSET "frontend:task:${TASK_ID}:context" \
-  "component_name" "${COMPONENT_NAME}" \
-  "mockup_path" "${MOCKUP_PATH}" \
-  "brand_guidelines" "${BRAND_GUIDELINES}" \
-  "mode" "${MODE}" \
-  "visual_threshold" "${VISUAL_THRESHOLD}" \
-  "max_iterations" "${MAX_ITERATIONS}" \
-  "current_iteration" "1"
 
 # Store brand guidelines for agent reference
 redis-cli SET "frontend:task:${TASK_ID}:brand-guidelines" "${BRAND_GUIDELINES_JSON}"
 redis-cli SET "frontend:task:${TASK_ID}:mockup-path" "${MOCKUP_PATH}"
-redis-cli HSET "frontend:task:${TASK_ID}:config" \
-  "visual_threshold" "85" \
-  "interaction_threshold" "80" \
-  "accessibility_threshold" "90"
 ```
 
 ### Agent Spawning with Redis Context
@@ -103,13 +84,6 @@ for agent in "${loop3Agents[@]}"; do
   AGENT_ID="${TASK_ID}-${agent}-$(date +%s)"
 
   # Store agent coordination data
-  redis-cli HSET "frontend:agent:${AGENT_ID}" \
-    "agent_type" "${agent}" \
-    "task_id" "${TASK_ID}" \
-    "loop_number" "3" \
-    "iteration" "${CURRENT_ITERATION}" \
-    "component_name" "${COMPONENT_NAME}" \
-    "status" "spawning"
 
   # Prepare enhanced context with brand guidelines
   CONTEXT_WITH_BRAND=$(cat <<EOF
@@ -161,13 +135,6 @@ store_visual_analysis() {
   local overall_score="$3"
   local iteration="$4"
 
-  redis-cli HSET "frontend:task:${TASK_ID}:visual:${iteration}" \
-    "similarity_score" "$similarity_score" \
-    "interaction_score" "$interaction_score" \
-    "overall_score" "$overall_score" \
-    "analyzed_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-    "screenshot_path" "${SCREENSHOT_PATH}" \
-    "video_path" "${VIDEO_PATH}"
 
   # Store visual feedback for iteration
   redis-cli SET "frontend:task:${TASK_ID}:feedback:${iteration}" "$VISUAL_FEEDBACK_JSON"
@@ -196,13 +163,6 @@ spawn_visual_validators() {
     AGENT_ID="${TASK_ID}-${validator}-$(date +%s)"
 
     # Store validator context
-    redis-cli HSET "frontend:agent:${AGENT_ID}" \
-      "agent_type" "${validator}" \
-      "task_id" "${TASK_ID}" \
-      "loop_number" "2" \
-      "iteration" "${CURRENT_ITERATION}" \
-      "component_name" "${COMPONENT_NAME}" \
-      "visual_score" "$OVERALL_SCORE"
 
     # Prepare validation context with visual artifacts
     VALIDATION_CONTEXT=$(cat <<EOF
@@ -255,11 +215,6 @@ signal_agent_completion() {
 
   if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
     # Store completion data
-    redis-cli HSET "frontend:task:${TASK_ID}:completion:${AGENT_ID}" \
-      "confidence" "$confidence" \
-      "iteration" "$iteration" \
-      "deliverables" "$deliverables" \
-      "completed_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
     # Signal completion
     redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
@@ -281,10 +236,6 @@ signal_validator_completion() {
 
   if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
     # Store validator consensus
-    redis-cli HSET "frontend:task:${TASK_ID}:validator:${AGENT_ID}" \
-      "consensus_score" "$consensus_score" \
-      "feedback" "$validation_feedback" \
-      "validated_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
     # Signal validation completion
     redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
@@ -306,13 +257,6 @@ signal_product_owner_decision() {
 
   if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
     # Store PO decision
-    redis-cli HSET "frontend:task:${TASK_ID}:po-decision" \
-      "decision" "$decision" \
-      "reasoning" "$reasoning" \
-      "final_score" "$OVERALL_SCORE" \
-      "final_consensus" "$FINAL_CONSENSUS" \
-      "total_iterations" "$CURRENT_ITERATION" \
-      "decided_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
     # Signal decision completion
     redis-cli lpush "swarm:${TASK_ID}:product-owner:done" "$decision"
@@ -355,11 +299,6 @@ store_iteration_result() {
   local score="$3"
   local feedback="$4"
 
-  redis-cli HSET "frontend:task:${TASK_ID}:audit:${iteration}" \
-    "status" "$status" \
-    "score" "$score" \
-    "feedback" "$feedback" \
-    "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
 ```
 
@@ -906,12 +845,14 @@ fi
 Complete your frontend coordination work and provide test-based validation:
 
 1. **Execute Tests**: Run all test suites from success criteria
-2. **Parse Results**: Use parse-test-results.sh helper
-3. **Report Metrics**:
-   - Total tests: X
-   - Passed: Y
-   - Failed: Z
-   - Pass rate: Y/X (e.g., 0.95)
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
+
+# Return results (Main Chat receives automatically in Task Mode)
+echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
    - Coverage: ≥80%
 4. **Store in Redis**: Use test-results key (not confidence key)
 5. **Signal Completion**: Push to completion queue

package/claude-assets/agents/cfn-dev-team/coordinators/cfn-v3-coordinator.md

@@ -46,25 +46,18 @@ fi
 
 **Old (Deprecated):**
 ```bash
-redis-cli HSET "swarm:${TASK_ID}:confidence:iteration${ITERATION}" \
-  "${AGENT_ID}" "0.85"
-```
 
 **New (Required):**
 ```bash
 # Execute tests and capture output
 TEST_OUTPUT=$(npm test 2>&1)
 
-# Parse test results
-RESULTS=$(./.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh \
-  "jest" "$TEST_OUTPUT")
-
-# Store in Redis
-redis-cli HSET "swarm:${TASK_ID}:test-results:iteration${ITERATION}" \
-  "${AGENT_ID}" "$RESULTS"
+# Parse natively (no external dependencies)
+PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
+FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
+TOTAL=$((PASS + FAIL))
+RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
 
-# Signal completion
-redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
 ```
 
 ## Success Criteria Auto-Generation (Phase 3)
@@ -346,23 +339,8 @@ When spawned via CLI (`cfn-spawn agent`), implement full Redis coordination:
 #### 1. Task Context Storage
 ```bash
 # Store task context in Redis for swarm recovery
-redis-cli HSET "cfn_loop:task:${TASK_ID}:context" \
-  "epic_goal" "${EPIC_GOAL}" \
-  "in_scope" "${IN_SCOPE}" \
-  "out_of_scope" "${OUT_OF_SCOPE}" \
-  "deliverables" "${DELIVERABLES}" \
-  "acceptance_criteria" "${ACCEPTANCE_CRITERIA}" \
-  "mode" "${MODE}" \
-  "gate_threshold" "${GATE_THRESHOLD}" \
-  "consensus_threshold" "${CONSENSUS_THRESHOLD}" \
-  "max_iterations" "${MAX_ITERATIONS}"
 
 # Store agent configuration
-redis-cli HSET "cfn_loop:task:${TASK_ID}:config" \
-  "loop3_agents" "${LOOP3_AGENTS}" \
-  "loop2_agents" "${LOOP2_AGENTS}" \
-  "product_owner" "${PRODUCT_OWNER}" \
-  "complexity" "${COMPLEXITY}"
 ```
 
 #### 2. Agent Spawning with Context Injection
@@ -372,12 +350,6 @@ for agent in "${loop3_agents[@]}"; do
   AGENT_ID="${TASK_ID}-${agent}-$(date +%s)"
 
   # Store agent-specific context
-  redis-cli HSET "cfn_loop:agent:${AGENT_ID}" \
-    "agent_type" "${agent}" \
-    "task_id" "${TASK_ID}" \
-    "loop_number" "3" \
-    "iteration" "1" \
-    "status" "spawning"
 
   # Inject context and spawn via CLI
   cfn-spawn agent "${agent}" \
@@ -426,10 +398,6 @@ if (( $(echo "$AVERAGE_CONFIDENCE >= $GATE_THRESHOLD" | bc -l) )); then
   echo "✅ Gate PASSED - signaling Loop 2"
 
   # Store gate result and broadcast signal
-  redis-cli HSET "cfn_loop:task:${TASK_ID}:gate_result" \
-    "status" "passed" \
-    "confidence" "$AVERAGE_CONFIDENCE" \
-    "iteration" "$CURRENT_ITERATION"
 
   # Signal Loop 2 agents to start
   redis-cli lpush "swarm:${TASK_ID}:gate-passed" "1"
@@ -440,10 +408,6 @@ else
   echo "❌ Gate FAILED - preparing Loop 3 iteration"
 
   # Store gate failure and prepare feedback
-  redis-cli HSET "cfn_loop:task:${TASK_ID}:gate_result" \
-    "status" "failed" \
-    "confidence" "$AVERAGE_CONFIDENCE" \
-    "iteration" "$CURRENT_ITERATION"
 
   # Prepare iteration feedback
   prepare_loop3_feedback
@@ -458,11 +422,6 @@ spawn_loop2_validators() {
     AGENT_ID="${TASK_ID}-${validator}-$(date +%s)"
 
     # Store validator context
-    redis-cli HSET "cfn_loop:agent:${AGENT_ID}" \
-      "agent_type" "${validator}" \
-      "task_id" "${TASK_ID}" \
-      "loop_number" "2" \
-      "iteration" "$CURRENT_ITERATION"
 
     # Inject validation context
     VALIDATION_CONTEXT=$(cat <<EOF
@@ -547,12 +506,6 @@ if [ -n "$PO_SIGNAL" ]; then
   PO_DECISION=$(redis-cli HGET "cfn_loop:task:${TASK_ID}:po_decision")
 
   # Store final result
-  redis-cli HSET "cfn_loop:task:${TASK_ID}:result" \
-    "decision" "$PO_DECISION" \
-    "final_confidence" "$AVERAGE_CONFIDENCE" \
-    "final_consensus" "$AVERAGE_CONSENSUS" \
-    "iterations_completed" "$CURRENT_ITERATION" \
-    "completion_time" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
   execute_decision "$PO_DECISION"
 fi
@@ -597,10 +550,6 @@ Co-Authored-By: Claude <noreply@anthropic.com>"
       CURRENT_ITERATION=$((CURRENT_ITERATION + 1))
 
       # Store iteration context
-      redis-cli HSET "cfn_loop:task:${TASK_ID}:iteration:${CURRENT_ITERATION}" \
-        "confidence" "$AVERAGE_CONFIDENCE" \
-        "consensus" "$AVERAGE_CONSENSUS" \
-        "feedback" "$(prepare_iteration_feedback)"
 
       # Restart Loop 3 with fresh agents
       restart_loop3_agents
@@ -631,10 +580,6 @@ signal_agent_completion() {
     redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 
     # Report confidence score
-    redis-cli HSET "cfn_loop:task:${TASK_ID}:confidence:${AGENT_ID}" \
-      "confidence" "$confidence" \
-      "iteration" "$iteration" \
-      "reported_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
     # Use coordination script for structured reporting
     ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
@@ -809,16 +754,27 @@ Extract deliverables from task description:
 
 ### Step 1: Task Classification (REQUIRED)
 ```bash
+# BUG #23 FIX: Store task classification in Redis to persist across Bash tool calls
+# Each Bash tool call creates a new shell, so environment variables don't persist
+# Redis provides persistence across iterations
+
 # Classify task type (use hardcoded defaults if script fails)
 TASK_TYPE="infrastructure"  # Default fallback
 if [[ -f ".claude/skills/task-classifier/classify-task.sh" ]]; then
   CLASSIFIED_TYPE=$(bash .claude/skills/task-classifier/classify-task.sh "$TASK_DESCRIPTION" 2>/dev/null || echo "")
   [[ -n "$CLASSIFIED_TYPE" ]] && TASK_TYPE="$CLASSIFIED_TYPE"
 fi
+
+# Store task type in Redis for persistence across Bash tool calls
+echo "✅ Task type '$TASK_TYPE' stored in Redis: swarm:${TASK_ID}:config"
 ```
 
 ### Step 2: Agent Selection with Fallback (REQUIRED)
 ```bash
+# BUG #23 FIX: Store agent selections in Redis to persist across Bash tool calls
+# Environment variables are lost between Bash tool executions
+# Redis ensures parameters persist through validation and orchestrator invocation
+
 # Select agents with hardcoded fallbacks (never fail)
 LOOP3_AGENTS="terraform-engineer,devops-engineer"  # Infrastructure default
 LOOP2_AGENTS="security-auditor,compliance-checker,cost-optimizer"  # Validation default
@@ -835,6 +791,120 @@ if [[ -f ".claude/skills/cfn-agent-selector/select-agents.sh" ]]; then
     [[ -n "$PARSED_AGENTS" ]] && LOOP2_AGENTS="$PARSED_AGENTS"
   fi
 fi
+
+# Store agent selections in Redis for persistence
+
+echo "✅ Agent selections stored in Redis:"
+echo "   loop3_agents: $LOOP3_AGENTS"
+echo "   loop2_agents: $LOOP2_AGENTS"
+echo "   product_owner: $PRODUCT_OWNER"
+```
+
+### Step 2.5: MANDATORY Parameter Initialization (BUG #22 & BUG #23 FIX)
+
+**CRITICAL: Execute this BEFORE orchestrator invocation to prevent empty parameter errors.**
+
+This step implements defense-in-depth fixes for both BUG #22 and BUG #23:
+- BUG #22: Empty parameter validation with hardcoded fallbacks
+- BUG #23: Redis-first parameter retrieval to handle Bash tool session loss
+
+```bash
+# BUG #23 FIX: Read parameters from Redis with fallbacks
+# Bash tool creates new shell each call, so variables set in Step 2 may be lost
+# Redis provides persistent storage across all Bash tool executions
+LOOP3_AGENTS=$(redis-cli HGET "swarm:${TASK_ID}:config" "loop3_agents" 2>/dev/null || echo "")
+LOOP2_AGENTS=$(redis-cli HGET "swarm:${TASK_ID}:config" "loop2_agents" 2>/dev/null || echo "")
+PRODUCT_OWNER=$(redis-cli HGET "swarm:${TASK_ID}:config" "product_owner" 2>/dev/null || echo "")
+
+echo "🔄 Parameters retrieved from Redis (BUG #23 fix)"
+echo "   LOOP3_AGENTS='$LOOP3_AGENTS'"
+echo "   LOOP2_AGENTS='$LOOP2_AGENTS'"
+echo "   PRODUCT_OWNER='$PRODUCT_OWNER'"
+
+# BUG #22 FIX: Apply fallbacks if Redis returns empty (defense-in-depth)
+# Even if Redis succeeded, re-validate and apply defaults if empty
+LOOP3_AGENTS="${LOOP3_AGENTS:-backend-developer,frontend-developer}"
+LOOP2_AGENTS="${LOOP2_AGENTS:-code-reviewer,tester,security-specialist}"
+PRODUCT_OWNER="${PRODUCT_OWNER:-product-owner}"
+
+echo "🔒 Fallback parameters initialized (BUG #22 prevention)"
+echo "   LOOP3_AGENTS='$LOOP3_AGENTS'"
+echo "   LOOP2_AGENTS='$LOOP2_AGENTS'"
+echo "   PRODUCT_OWNER='$PRODUCT_OWNER'"
+
+# MANDATORY: Validate before orchestrator invocation
+if [[ -z "$LOOP3_AGENTS" ]] || [[ -z "$LOOP2_AGENTS" ]] || [[ -z "$PRODUCT_OWNER" ]]; then
+  echo "❌ FATAL: Agent parameters cannot be empty after Redis retrieval + fallback initialization" >&2
+  echo "   This indicates a critical logic error in parameter handling (BUG #22 & #23)" >&2
+  echo "   LOOP3_AGENTS='$LOOP3_AGENTS'" >&2
+  echo "   LOOP2_AGENTS='$LOOP2_AGENTS'" >&2
+  echo "   PRODUCT_OWNER='$PRODUCT_OWNER'" >&2
+  exit 1
+fi
+
+echo "✅ All parameters validated non-empty before orchestrator invocation (BUG #22 & #23 fixes applied)"
+```
+
+**Why This Matters:**
+
+1. **BUG #23 Fix - Redis Persistence**: Each Bash tool call creates a new shell
+   - Environment variables set in iteration N are lost in iteration N+1
+   - Redis provides persistent storage across all Bash tool executions
+   - Parameters stored in Step 2 are reliably retrieved in Step 2.5
+   - Prevents coordinator from being stuck in validation loop
+
+2. **BUG #22 Fix - Defense-in-Depth**: Multiple layers of protection against empty parameters
+   - Step 2 provides hardcoded defaults AND stores in Redis
+   - Step 2.5 reads from Redis then applies fallbacks if Redis fails
+   - Explicit validation catches any logic errors before orchestrator call
+
+3. **Clear Error Messages**: If validation fails, provides:
+   - Exact parameter values (shows what went wrong)
+   - Context about where failure occurred (BUG #22 or BUG #23)
+   - Actionable error message (indicates critical logic error)
+
+4. **Fail-Fast Principle**: Better to exit early with clear error than pass empty strings to orchestrator
+   - Orchestrator would fail with confusing error messages
+   - Empty parameters cause cascade failures in agent spawning
+   - Early validation prevents wasted iteration time
+
+**Testing BUG #22 & BUG #23 Fixes:**
+
+```bash
+# Test BUG #23 fix (Redis persistence across Bash tool calls)
+# Simulate multiple Bash tool executions (coordinator iterations)
+npx claude-flow-novice agent-spawn cfn-v3-coordinator \
+  --task-id test-bug23 \
+  --env TASK_DESCRIPTION="Test Redis parameter persistence"
+
+# Expected output in Step 2:
+# ✅ Agent selections stored in Redis:
+#    loop3_agents: backend-developer,frontend-developer
+#    loop2_agents: code-reviewer,tester,security-specialist
+#    product_owner: product-owner
+
+# Expected output in Step 2.5 (even in NEW Bash shell):
+# 🔄 Parameters retrieved from Redis (BUG #23 fix)
+#    LOOP3_AGENTS='backend-developer,frontend-developer'
+#    LOOP2_AGENTS='code-reviewer,tester,security-specialist'
+#    PRODUCT_OWNER='product-owner'
+# ✅ All parameters validated non-empty before orchestrator invocation (BUG #22 & #23 fixes applied)
+
+# Test BUG #22 fix (fallbacks when Redis fails)
+# Simulate Redis failure
+redis-cli SHUTDOWN NOSAVE
+
+# Run coordinator - should fall back to defaults
+npx claude-flow-novice agent-spawn cfn-v3-coordinator \
+  --task-id test-bug22 \
+  --env TASK_DESCRIPTION="Test fallback parameters"
+
+# Expected output:
+# 🔄 Parameters retrieved from Redis (BUG #23 fix)
+#    LOOP3_AGENTS=''  (Redis down)
+# 🔒 Fallback parameters initialized (BUG #22 prevention)
+#    LOOP3_AGENTS='backend-developer,frontend-developer'
+# ✅ All parameters validated non-empty before orchestrator invocation (BUG #22 & #23 fixes applied)
 ```
 
 ### Step 3: INVOKE ORCHESTRATOR (MANDATORY - NOT OPTIONAL)
@@ -842,15 +912,51 @@ fi
 **CRITICAL:** You MUST invoke orchestrator by iteration 3. DO NOT complete tasks directly.
 
 ```bash
+# BUG #23 FIX: Read parameters from Redis before invoking orchestrator
+# This ensures we use the SAME parameters that were validated in Step 2.5
+# Even if this is executed in a NEW Bash shell (which it likely is)
+LOOP3_AGENTS=$(redis-cli HGET "swarm:${TASK_ID}:config" "loop3_agents" 2>/dev/null || echo "backend-developer,frontend-developer")
+LOOP2_AGENTS=$(redis-cli HGET "swarm:${TASK_ID}:config" "loop2_agents" 2>/dev/null || echo "code-reviewer,tester,security-specialist")
+PRODUCT_OWNER=$(redis-cli HGET "swarm:${TASK_ID}:config" "product_owner" 2>/dev/null || echo "product-owner")
+
+# Apply final fallbacks if Redis returns empty (defense-in-depth)
+LOOP3_AGENTS="${LOOP3_AGENTS:-backend-developer,frontend-developer}"
+LOOP2_AGENTS="${LOOP2_AGENTS:-code-reviewer,tester,security-specialist}"
+PRODUCT_OWNER="${PRODUCT_OWNER:-product-owner}"
+
+echo "🔄 Orchestrator parameters loaded from Redis (BUG #23 fix):"
+echo "   LOOP3_AGENTS='$LOOP3_AGENTS'"
+echo "   LOOP2_AGENTS='$LOOP2_AGENTS'"
+echo "   PRODUCT_OWNER='$PRODUCT_OWNER'"
+
 # ALWAYS invoke orchestrator - this is your ONLY responsibility
-./.claude/skills/cfn-loop-orchestration/orchestrate.sh \
+
+# Store success criteria in Redis BEFORE spawning orchestrator
+REDIS_KEY="swarm:${TASK_ID}:context"
+cat <<'CRITERIA_EOF' | redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" -x HSET "$REDIS_KEY" "success-criteria"
+{
+  "deliverables": [],
+  "acceptanceCriteria": ["Implementation complete"],
+  "test_suites": []
+}
+CRITERIA_EOF
+
+# Set TTL on context hash (24 hours)
+redis-cli -h "${REDIS_HOST:-localhost}" -p "${REDIS_PORT:-6379}" EXPIRE "$REDIS_KEY" 86400
+
+echo "✅ Success criteria stored in Redis: $REDIS_KEY"
+
+# BUG #22 & BUG #23 FIX: Use orchestrate-wrapper.sh with Redis-backed parameters
+# BUG #22: Wrapper provides additional validation and error handling
+# BUG #23: Parameters are read from Redis to survive Bash tool session boundaries
+./.claude/skills/cfn-loop-orchestration/orchestrate-wrapper.sh \
   --task-id "$TASK_ID" \
   --mode "standard" \
   --loop3-agents "$LOOP3_AGENTS" \
   --loop2-agents "$LOOP2_AGENTS" \
   --product-owner "$PRODUCT_OWNER" \
   --max-iterations 10 \
-  --success-criteria '{"deliverables":[],"acceptanceCriteria":["Implementation complete"]}'
+  --success-criteria "enabled"
 
 # The orchestrator handles ALL CFN Loop execution including:
 # - Loop 3 agent spawning and iteration
@@ -864,10 +970,14 @@ fi
 
 **EXECUTION GUARANTEE:**
 - If steps 1-2 fail, use hardcoded defaults and proceed to step 3
+- **Step 2 stores parameters in Redis** (BUG #23 fix - persistence)
+- **Step 2.5 validates parameters from Redis** (BUG #22 + BUG #23 fix - retrieval + fallbacks)
+- **Step 3 reads parameters from Redis** (BUG #23 fix - fresh shell reads from persistent storage)
 - **Never exit without invoking orchestrator**
 - **Orchestrator invocation MUST happen by iteration 3**
 - This coordinator's ONLY job is to configure and invoke the orchestrator
 
+
 ## Multi-Worktree Coordination
 
 When spawning agents in multi-worktree environments (teams using git worktrees), inject environment variables for proper Docker isolation: