claude-flow-novice 2.14.27 → 2.14.29

package/.claude/skills/cfn-product-owner-decision/execute-decision.sh

@@ -77,10 +77,49 @@ echo -e "${YELLOW}📥 Retrieving Loop 2 context...${NC}"
 LOOP2_FEEDBACK=$(redis-cli HGET "swarm:${TASK_ID}:loop2:consensus" "feedback" || echo "")
 TASK_CONTEXT=$(redis-cli HGETALL "swarm:${TASK_ID}:context" || echo "")
 
-# Build Product Owner context
+# Retrieve comprehensive audit trail data
+echo -e "${YELLOW}🔍 Retrieving audit trail data for informed decision-making...${NC}"
+set +e
+AUDIT_DATA=$(./.claude/skills/cfn-task-audit/get-audit-data.sh \
+  --task-id "$TASK_ID" \
+  --mode combined \
+  --format json 2>/dev/null || echo "[]")
+
+AUDIT_SUMMARY=$(./.claude/skills/cfn-task-audit/get-audit-data.sh \
+  --task-id "$TASK_ID" \
+  --mode combined \
+  --format summary 2>/dev/null || echo "No audit data available")
+set -e
+
+# Analyze audit data for patterns
+AUDIT_INSIGHTS=""
+if [ "$AUDIT_DATA" != "[]" ]; then
+  # Extract key patterns from audit data
+  PREVIOUS_DECISIONS=$(echo "$AUDIT_DATA" | jq -r '.[] | select(.agent_type == "product-owner") | .decision' 2>/dev/null | tr '\n' ', ' | sed 's/,$//' || echo "None")
+  AGENT_PERFORMANCE=$(echo "$AUDIT_DATA" | jq -r 'group_by(.agent_type) | map({agent: .[0].agent_type, avg_confidence: map(.confidence) | add / length}) | sort_by(.avg_confidence) | reverse | .[0:3] | .[] | "\(.agent): \(.avg_confidence)"' 2>/dev/null || echo "No performance data")
+
+  # Check for repeating concerns
+  REPEATING_CONCERNS=$(echo "$AUDIT_DATA" | jq -r '.[] | select(.agent_type == "reviewer" or .agent_type == "tester") | .reasoning | scan("security|performance|scope|quality|bug")' 2>/dev/null | sort | uniq -c | sort -nr | head -3 | awk '{print $2 " (" $1 "x)"}' | tr '\n' ', ' | sed 's/,$//' || echo "No repeating concerns")
+
+  AUDIT_INSIGHTS="
+AUDIT TRAIL INSIGHTS:
+- Previous Product Owner Decisions: $PREVIOUS_DECISIONS
+- Top Performing Agents: $AGENT_PERFORMANCE
+- Repeating Concerns: $REPEATING_CONCERNS
+- Total Audit Records: $(echo "$AUDIT_DATA" | jq '. | length' 2>/dev/null || echo "0")
+
+Audit Summary:
+$AUDIT_SUMMARY
+"
+else
+  AUDIT_INSIGHTS="AUDIT TRAIL: No historical data available for this task."
+fi
+
+# Build enhanced Product Owner context with audit insights
 PO_CONTEXT="
 You are the Product Owner making a strategic decision for CFN Loop iteration $ITERATION of $MAX_ITERATIONS.
 
+CURRENT ITERATION DATA:
 Loop 2 Consensus: $CONSENSUS
 Threshold: $THRESHOLD
 Success Criteria: ${SUCCESS_CRITERIA:-"Not specified"}
@@ -91,15 +130,26 @@ $LOOP2_FEEDBACK
 Task Context:
 $TASK_CONTEXT
 
-Make a strategic decision:
-- PROCEED: Quality threshold met, deliverables complete
-- ITERATE: Improvements needed, iterations remaining
-- ABORT: Max iterations reached or unrecoverable failure
+$AUDIT_INSIGHTS
+
+ENHANCED DECISION FRAMEWORK:
+Use the audit trail insights to inform your decision. Consider:
+- Are there repeating concerns that suggest systematic issues?
+- Which agents have performed well on similar tasks?
+- Do previous decisions show a pattern of success or failure?
+- Are there cross-mode inconsistencies that need attention?
+
+DECISION OPTIONS:
+- PROCEED: Quality threshold met, deliverables complete, audit shows positive trajectory
+- ITERATE: Improvements needed, iterations remaining, audit shows recoverable issues
+- ABORT: Max iterations reached, systematic failure, or audit shows insurmountable barriers
 
 Output format:
 Decision: PROCEED|ITERATE|ABORT
-Reasoning: [your explanation]
+Reasoning: [your explanation + audit insights]
 Confidence: [0.0-1.0]
+Audit Analysis: [brief summary of how audit data influenced your decision]
+Agent Performance: [any observations about agent reliability from audit trail]
 "
 
 # Spawn Product Owner agent
@@ -144,6 +194,12 @@ else
 
     # Parse confidence
     CONFIDENCE=$(echo "$PO_OUTPUT" | grep -oE "Confidence:\s*[0-9]+\.?[0-9]*" | grep -oE "[0-9]+\.?[0-9]*" || echo "0.85")
+
+    # Parse audit analysis (enhanced output)
+    AUDIT_ANALYSIS=$(echo "$PO_OUTPUT" | grep -oiE "Audit Analysis:\s*.*" | sed 's/Audit Analysis:\s*//' || echo "No audit analysis provided")
+
+    # Parse agent performance observations
+    AGENT_PERFORMANCE_OBSERVATIONS=$(echo "$PO_OUTPUT" | grep -oiE "Agent Performance:\s*.*" | sed 's/Agent Performance:\s*//' || echo "No agent performance observations")
   else
     echo -e "${RED}❌ ERROR: Product Owner output file missing or empty${NC}"
     echo "Expected: $PO_OUTPUT_FILE"
@@ -167,6 +223,11 @@ fi
 echo -e "${GREEN}✅ Product Owner Decision: $DECISION_TYPE${NC}"
 echo "Reasoning: $REASONING"
 echo "Confidence: $CONFIDENCE"
+if [ "$AUDIT_DATA" != "[]" ]; then
+  echo -e "${BLUE}📊 Audit Analysis: $AUDIT_ANALYSIS${NC}"
+  echo -e "${BLUE}🏆 Agent Performance: $AGENT_PERFORMANCE_OBSERVATIONS${NC}"
+  echo -e "${BLUE}📈 Audit Records Analyzed: $(echo "$AUDIT_DATA" | jq '. | length' 2>/dev/null || echo "0")${NC}"
+fi
 
 # Deliverable verification for PROCEED decisions
 if [ "$DECISION_TYPE" = "PROCEED" ]; then
@@ -254,7 +315,7 @@ else
   echo -e "${GREEN}No deferred items detected in Product Owner output${NC}"
 fi
 
-# Build decision JSON
+# Build enhanced decision JSON with audit insights
 DECISION_JSON=$(cat <<EOF
 {
   "decision": "$DECISION_TYPE",
@@ -263,17 +324,25 @@ DECISION_JSON=$(cat <<EOF
   "iteration": $ITERATION,
   "consensus": $CONSENSUS,
   "threshold": $THRESHOLD,
-  "timestamp": $(date +%s)
+  "timestamp": $(date +%s),
+  "audit_analysis": "$AUDIT_ANALYSIS",
+  "agent_performance_observations": "$AGENT_PERFORMANCE_OBSERVATIONS",
+  "audit_records_analyzed": $(echo "$AUDIT_DATA" | jq '. | length' 2>/dev/null || echo "0"),
+  "audit_informed": $(if [ "$AUDIT_DATA" != "[]" ]; then echo "true"; else echo "false"; fi)
 }
 EOF
 )
 
-# Store decision in Redis
-echo -e "${YELLOW}💾 Storing decision in Redis...${NC}"
+# Store decision in Redis with audit context
+echo -e "${YELLOW}💾 Storing decision in Redis with audit context...${NC}"
 redis-cli LPUSH "swarm:${TASK_ID}:decision" "$DECISION_TYPE"
 redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "decision" "$DECISION_TYPE"
 redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "reasoning" "$REASONING"
 redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "confidence" "$CONFIDENCE"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "audit_analysis" "$AUDIT_ANALYSIS"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "agent_performance_observations" "$AGENT_PERFORMANCE_OBSERVATIONS"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "audit_records_analyzed" "$(echo "$AUDIT_DATA" | jq '. | length' 2>/dev/null || echo "0")"
+redis-cli HSET "swarm:${TASK_ID}:${AGENT_ID}:result" "audit_informed" "$(if [ "$AUDIT_DATA" != "[]" ]; then echo "true"; else echo "false"; fi)"
 
 # Store in metrics
 redis-cli LPUSH "swarm:${TASK_ID}:metrics:product_owner_decisions" "$DECISION_JSON"
@@ -293,3 +362,6 @@ redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
 echo "$DECISION_JSON"
 
 echo -e "${GREEN}✅ Product Owner decision execution complete${NC}"
+if [ "$AUDIT_DATA" != "[]" ]; then
+  echo -e "${BLUE}📊 Decision was informed by audit trail analysis${NC}"
+fi

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

@@ -42,6 +42,16 @@ while [[ $# -gt 0 ]]; do
     esac
 done
 
+# ⚠️ ANTI-023 MEMORY LEAK PROTECTION: Block Task Mode agents
+# Task Mode agents spawn via Task() tool and should NOT use Redis coordination
+if [[ -z "${TASK_ID:-}" || -z "${AGENT_ID:-}" ]]; then
+    echo "❌ TASK MODE DETECTED - Redis coordination forbidden" >&2
+    echo "🚨 ANTI-023: This script is for CLI-spawned agents only" >&2
+    echo "💡 Task Mode agents should return JSON directly to Main Chat" >&2
+    echo "🔧 Agent spawned via Task() tool - use structured JSON output instead" >&2
+    exit 1
+fi
+
 # Validate required parameters
 if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
     echo "Error: Missing required parameters" >&2

package/claude-assets/agents/cfn-dev-team/architecture/base-template-generator.md

@@ -145,38 +145,12 @@ Quality standards:
 
 When generating templates, always consider the broader project context, existing patterns, and future extensibility needs. Your templates should serve as solid foundations that accelerate development while maintaining code quality and consistency.
 
-## CFN Loop Redis Completion Protocol
+## Completion Protocol
 
-When participating in CFN Loop workflows, agents MUST follow this protocol:
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on work quality
+- Summary of analysis/review completed
+- List of findings or deliverables
+- Any recommendations made
 
-### Step 1: Complete Work
-Execute assigned task (template generation, boilerplate code creation, project scaffolding)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score and Exit
-```bash
-./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-**After reporting, exit cleanly. Do NOT enter waiting mode.**
-
-**Why This Matters:**
-- Orchestrator collects confidence/consensus scores from Redis
-- Enables adaptive agent specialization for next iteration
-- Prevents orchestrator blocking on wait $PID
-- Coordinator spawns appropriate specialist based on feedback type
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "base-template-generator-1")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+**Note:** Coordination instructions are provided when spawned via CLI.

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

@@ -127,53 +127,13 @@ plan:
 
 Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress.
 
-## CFN Loop Redis Completion Protocol
+## Completion Protocol
 
-When participating in CFN Loop workflows, agents MUST follow this protocol:
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on work quality
+- Summary of analysis/review completed
+- List of findings or deliverables
+- Any recommendations made
 
-### Step 1: Complete Work
-Execute assigned task (task planning, dependency mapping, resource allocation, risk assessment)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-
-**After reporting, exit cleanly. Do NOT enter waiting mode.**
-
-**Why This Matters:**
-- Orchestrator collects confidence/consensus scores from Redis
-- Enables adaptive agent specialization for next iteration
-- Prevents orchestrator blocking on wait $PID
-- Coordinator spawns appropriate specialist based on feedback type
-
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "iteration-complete"
-```
-
-**Why This Matters:**
-- Zero-token blocking coordination (BLPOP waits without API calls)
-- Orchestrator collects confidence/consensus scores automatically
-- Supports autonomous iteration based on quality gates
-- Agent woken instantly (<100ms) if iteration needed
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "planner-1")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details
+**Note:** Coordination instructions are provided when spawned via CLI.
 

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

@@ -122,38 +122,12 @@ await sqlite.memoryAdapter.set(
 ```
 
 **Core Insight:** Great architecture balances technical excellence with business needs, making informed trade-offs that enable long-term system health and adaptability.
-## CFN Loop Redis Completion Protocol
+## Completion Protocol
 
-When participating in CFN Loop workflows, agents MUST follow this protocol:
+Complete your architectural work and provide a structured response with:
+- Confidence score (0.0-1.0) based on architectural quality
+- Summary of design decisions made
+- List of deliverables created
+- Any assumptions or constraints identified
 
-### Step 1: Complete Work
-Execute assigned task (system architecture design, technical strategy, infrastructure planning)
-
-### Step 2: Signal Completion
-```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-### Step 3: Report Confidence Score and Exit
-```bash
-./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-**After reporting, exit cleanly. Do NOT enter waiting mode.**
-
-**Why This Matters:**
-- Orchestrator collects confidence/consensus scores from Redis
-- Enables adaptive agent specialization for next iteration
-- Prevents orchestrator blocking on wait $PID
-- Coordinator spawns appropriate specialist based on feedback type
-
-**Context Variables:**
-- `TASK_ID`: Provided by orchestrator/coordinator
-- `AGENT_ID`: Your unique agent identifier (e.g., "system-architect-1")
-- Confidence: Self-assessment score based on architectural design quality and comprehensiveness (0.0-1.0)
-
-See: `.claude/skills/cfn-redis-coordination/SKILL.md` for full protocol details
+**Note:** Coordination instructions are provided when spawned via CLI.

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

@@ -62,14 +62,21 @@ fs.writeFileSync('.claude/brand-guidelines.json', JSON.stringify(brandGuidelines
 
 If brand guidelines provided, use those directly.
 
-**Step 4: Store Context in Redis**
+**Step 4: Store Context for Agent Reference**
+Store brand guidelines and context in Redis for agent coordination:
 ```bash
-# Store epic/phase context
-redis-cli hset "cfn_loop:task:${TASK_ID}:context" \
-  "mockupPath" "${MOCKUP_PATH}" \
-  "brandGuidelines" "$(cat .claude/brand-guidelines.json)" \
-  "visualThreshold" "85" \
-  "mode" "${MODE}"
+# Store brand guidelines in Redis for agents
+redis-cli HSET "cfn_loop:task:$TASK_ID:frontend" \
+  "brand_guidelines" "${BRAND_GUIDELINES}" \
+  "mockup_path" "${MOCKUP_PATH}" \
+  "mode" "${MODE}" \
+  "component_name" "${COMPONENT_NAME}" \
+  "visual_threshold" "85"
+
+# Store brand guidelines file for reference
+echo "${BRAND_GUIDELINES}" > .claude/frontend-brand-guidelines.json
+echo "${MOCKUP_PATH}" > .claude/frontend-mockup-path.txt
+echo "${MODE}" > .claude/frontend-mode.txt
 ```
 
 ### Phase 1: Loop 3 - Implementation with Visual Context
@@ -208,9 +215,8 @@ if (overallScore >= 85) {
     ]
   };
 
-  // Store feedback in Redis for next iteration
-  redis-cli hset "cfn_loop:task:${TASK_ID}:feedback" \
-    "iteration_${iteration}" "$(echo "$visualFeedback" | jq -c .)"
+  // Store feedback for next iteration
+  echo "$visualFeedback" | jq -c . > .claude/frontend-feedback-iteration-${iteration}.json
 }
 ```
 
@@ -221,6 +227,12 @@ if [ "$overallScore" -lt 85 ] && [ "$iteration" -lt "$MAX_ITERATIONS" ]; then
 
   echo "Starting iteration $iteration with visual feedback..."
 
+  # Store iteration context in Redis
+  redis-cli HSET "cfn_loop:task:$TASK_ID:iteration" \
+    "current_iteration" "$iteration" \
+    "previous_score" "$overallScore" \
+    "visual_feedback" "$(echo "$visualFeedback" | jq -c .)"
+
   # Spawn fresh Loop 3 agents for next iteration with feedback
   for agent in "${loop3Agents[@]}"; do
     npx claude-flow-novice agent-spawn "$agent" \
@@ -242,6 +254,11 @@ EOF
   # Repeat Phase 1 → Phase 2
 else
   echo "Visual validation complete or max iterations reached"
+  # Store completion in Redis
+  redis-cli HSET "cfn_loop:task:$TASK_ID:visual" \
+    "validation_complete" "true" \
+    "final_score" "$overallScore" \
+    "total_iterations" "$iteration"
   # Proceed to Phase 3
 fi
 ```
@@ -292,12 +309,21 @@ wait "${VALIDATOR_PIDS[@]}"
 ```
 
 **Collect Consensus:**
+Gather validator feedback and calculate consensus score from their outputs:
 ```bash
-CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
-  --task-id "$TASK_ID" \
-  --agent-ids "$(IFS=,; echo "${loop2Agents[*]}")")
-
-echo "Loop 2 consensus: $CONSENSUS"
+# Store validator context in Redis
+redis-cli HSET "cfn_loop:task:$TASK_ID:validation" \
+  "loop2_agents" "$(echo "${loop2Agents[@]}" | tr ' ' ',')" \
+  "validation_start" "$(date +%s)"
+
+# Collect validator outputs and calculate consensus
+CONSENSUS_SCORE=$(calculate-consensus-from-outputs.sh "${VALIDATOR_OUTPUTS[@]}")
+echo "Loop 2 consensus: $CONSENSUS_SCORE"
+
+# Store consensus result
+redis-cli HSET "cfn_loop:task:$TASK_ID:validation" \
+  "consensus_score" "$CONSENSUS_SCORE" \
+  "validation_complete" "true"
 ```
 
 ### Phase 4: Loop 4 - Product Owner Decision
@@ -318,7 +344,7 @@ Deliverables:
 $(git diff --name-only HEAD | grep -E '\.(tsx?|jsx?|css)$')
 
 Validation results:
-$(redis-cli hget "cfn_loop:task:${TASK_ID}:validation" "loop2_results")
+$(cat .claude/frontend-validation-results.json 2>/dev/null || echo "Validation results pending")
 
 DECISION CRITERIA:
 - Visual + interaction score ≥85%
@@ -339,6 +365,14 @@ EOF
 DECISION=$(./.claude/skills/cfn-product-owner-decision/parse-decision.sh \
   --output "$PO_OUTPUT")
 
+# Store decision in Redis
+redis-cli HSET "cfn_loop:task:$TASK_ID:decision" \
+  "decision" "$DECISION" \
+  "decision_time" "$(date +%s)" \
+  "final_score" "$overallScore" \
+  "consensus" "$CONSENSUS" \
+  "iterations" "$iteration"
+
 if [ "$DECISION" = "PROCEED" ]; then
   echo "✅ Product Owner approved - committing changes"
 
@@ -361,6 +395,12 @@ Co-Authored-By: Claude <noreply@anthropic.com>"
 
   git push origin main
 
+  # Mark epic complete in Redis
+  redis-cli HSET "cfn_loop:task:$TASK_ID:status" \
+    "status" "complete" \
+    "completion_time" "$(date +%s)" \
+    "git_commit" "$(git rev-parse HEAD)"
+
   # Generate component documentation
   cat > "docs/${COMPONENT_NAME}_IMPLEMENTATION.md" <<EOF
 # ${COMPONENT_NAME} Implementation
@@ -390,6 +430,7 @@ elif [ "$DECISION" = "ITERATE" ]; then
 
   if [ "$iteration" -ge "$MAX_ITERATIONS" ]; then
     echo "❌ Max iterations reached, aborting"
+    redis-cli HSET "cfn_loop:task:$TASK_ID:status" "status" "aborted_max_iterations"
     exit 1
   fi
 
@@ -398,6 +439,7 @@ elif [ "$DECISION" = "ITERATE" ]; then
 
 else
   echo "❌ Product Owner aborted"
+  redis-cli HSET "cfn_loop:task:$TASK_ID:status" "status" "aborted_by_product_owner"
   exit 1
 fi
 ```
@@ -407,13 +449,12 @@ fi
 **You MUST use the orchestrator script for dependency enforcement:**
 
 ```bash
-# Store all context in Redis first
-redis-cli hset "cfn_loop:task:${TASK_ID}:context" \
-  "mockupPath" "${MOCKUP_PATH}" \
-  "brandGuidelines" "$(cat .claude/brand-guidelines.json)" \
-  "visualThreshold" "85" \
-  "componentName" "${COMPONENT_NAME}" \
-  "taskDescription" "${TASK_DESCRIPTION}"
+# Store all context for orchestrator
+echo "${MOCKUP_PATH}" > .claude/frontend-mockup-path.txt
+cat .claude/brand-guidelines.json > .claude/frontend-brand-guidelines.json
+echo "85" > .claude/frontend-visual-threshold.txt
+echo "${COMPONENT_NAME}" > .claude/frontend-component-name.txt
+echo "${TASK_DESCRIPTION}" > .claude/frontend-task-description.txt
 
 # Invoke orchestrator (handles all spawning + dependency coordination)
 ./.claude/skills/cfn-loop-orchestration/cfn-orchestrate.sh \
@@ -528,9 +569,33 @@ if ! command -v playwright &> /dev/null; then
 fi
 ```
 
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute assigned coordination tasks
+
+### Step 2: Signal Completion
+```bash
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Step 3: Report Confidence Score and Exit
+```bash
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```
+
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
+
 ## Related Documentation
 
 - Guide: `.claude/commands/cfn/CFN_LOOP_FRONTEND.md`
 - Task Mode Guide: `.claude/commands/cfn/CFN_LOOP_TASK_MODE.md`
 - Coordinator Parameters: `.claude/commands/cfn/CFN_COORDINATOR_PARAMETERS.md`
 - Standard CFN Loop: `.claude/commands/cfn/cfn-loop.md`
+- Redis Coordination: `.claude/skills/cfn-redis-coordination/SKILL.md`

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

@@ -334,24 +334,37 @@ If you need Task Mode, use the slash command, not this agent.
 
 ### Redis Context Storage
 
+Store task configuration in Redis for agent coordination:
 ```bash
-# Redis key structure for task context
-KEY="cfn_loop:task:${TASK_ID}:context"
-
-# Store task configuration
-redis-cli HMSET "$KEY" \
-  task_type "$TASK_TYPE" \
-  loop3_agents "$(jq -c '.loop3_agents' <<< "$CONFIG")" \
-  loop2_agents "$(jq -c '.loop2_agents' <<< "$CONFIG")" \
-  validation_criteria "$(jq -c '.validation_criteria' <<< "$CONFIG")" \
-  deliverables "$(jq -c '.deliverables' <<< "$CONFIG")" \
-  gate_threshold "$GATE_THRESHOLD" \
-  consensus_threshold "$CONSENSUS_THRESHOLD" \
-  max_iterations "$MAX_ITERATIONS" \
-  complexity "$COMPLEXITY" \
-  reasoning "$REASONING"
-
-# Redis context supports zero-token agent coordination
+# Store epic context
+redis-cli HSET "cfn_loop:task:$TASK_ID:context" \
+  "task_type" "$TASK_TYPE" \
+  "loop3_agents" "$(jq -c '.loop3_agents' <<< "$CONFIG")" \
+  "loop2_agents" "$(jq -c '.loop2_agents' <<< "$CONFIG")" \
+  "validation_criteria" "$(jq -c '.validation_criteria' <<< "$CONFIG")" \
+  "deliverables" "$(jq -c '.deliverables' <<< "$CONFIG")" \
+  "gate_threshold" "$GATE_THRESHOLD" \
+  "consensus_threshold" "$CONSENSUS_THRESHOLD" \
+  "max_iterations" "$MAX_ITERATIONS" \
+  "complexity" "$COMPLEXITY" \
+  "reasoning" "$REASONING"
+
+# Store phase context
+redis-cli HSET "cfn_loop:task:$TASK_ID:phase" \
+  "current_phase" "1" \
+  "total_phases" "1" \
+  "phase_name" "Implementation"
+```
+
+### Context Retrieval
+
+Agents retrieve context from Redis:
+```bash
+# Get task context
+redis-cli HGETALL "cfn_loop:task:$TASK_ID:context"
+
+# Get current phase
+redis-cli HGET "cfn_loop:task:$TASK_ID:phase" "current_phase"
 ```
 
 ### Routing & Z.ai Provider Integration
@@ -427,22 +440,45 @@ Mode: task
 - Validation criteria appropriate for task
 - Deliverables are realistic file paths
 - Reasoning explains key decisions
-- Redis context storage successful
+- Context files created successfully
 - Correct routing based on mode
 
-### Redis Coordination Validation
+### Context Validation
 
 ```bash
 # Verify context stored correctly
-STORED_CONTEXT=$(redis-cli HGETALL "cfn_loop:task:${TASK_ID}:context")
+STORED_CONTEXT=$(cat .claude/cfn-context/task-${TASK_ID}.json)
 echo "$STORED_CONTEXT" | jq .
 ```
 
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute assigned coordination tasks
+
+### Step 2: Signal Completion
+```bash
+redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+```
+
+### Step 3: Report Confidence Score and Exit
+```bash
+./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```
+
+**After reporting, exit cleanly. Do NOT enter waiting mode.**
+
 ### Coordinator Post-Processing
 
 Coordinator checks:
-1. Redis context populated ✅
-2. Routing mode confirmed ✅
+1. Redis context stored ✅
+2. Orchestrator invoked ✅
 3. Agent selection validated ✅
 
-Remember: You are a configuration generator and context manager. Analyze tasks, generate recommendations, coordinate Redis context, enable zero-token agent workflows.
+Remember: You are a configuration generator and context manager. Analyze tasks, generate recommendations, coordinate Redis context storage, enable efficient agent workflows.