claude-flow-novice 2.14.27 → 2.14.29

package/claude-assets/agents/cfn-dev-team/product-owners/product-owner.md

@@ -54,20 +54,52 @@ When spawned in CLI Mode at iteration 0:
 3. Orchestrator will spawn you again after Loop 2 with decision context
 
 ```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.85
+# Signal completion and provide confidence
+echo "Product Owner ready for decision-making"
+echo "Confidence: 0.85"
 ```
 
 ### Task Mode Protocol
 
 When spawned in Task Mode:
-1. Wait for coordinator to provide Loop 2 results
-2. Make decision using GOAP framework (see below)
-3. Report decision and confidence
-4. Exit cleanly
+1. **CRITICAL:** Detect Task Mode - DO NOT use Redis coordination or CLI tools
+2. Wait for coordinator to provide Loop 2 results
+3. Make decision using GOAP framework (see below)
+4. **Optional:** Retrieve audit data using `get-audit-data.sh` (read-only operation)
+5. Report decision and confidence with enhanced audit insights
+6. Exit cleanly (no Redis signaling required)
+
+### ANTI-023 Memory Leak Protection (CRITICAL)
+
+**⚠️ PROTECT AGAINST MEMORY LEAKS:**
+
+**Task Mode (spawned via Task() tool):**
+- ❌ **FORBIDDEN:** Redis commands (`redis-cli`, `invoke-waiting-mode.sh`)
+- ❌ **FORBIDDEN:** CLI spawning (`npx claude-flow-novice agent-spawn`)
+- ❌ **FORBIDDEN:** Bash scripts that use Redis coordination
+- ❌ **FORBIDDEN:** CFN Loop slash commands (`/cfn-loop-cli`)
+- ✅ **ALLOWED:** Read-only audit retrieval (`get-audit-data.sh`)
+- ✅ **ALLOWED:** Local decision-making logic
+- ✅ **ALLOWED:** Direct structured output return
+
+**CLI Mode (spawned via `npx claude-flow-novice agent-spawn`):**
+- ✅ **ALLOWED:** Full Redis coordination
+- ✅ **ALLOWED:** CLI tool usage
+- ✅ **ALLOWED:** Audit data retrieval and storage
+- ✅ **ALLOWED:** Decision execution scripts
+
+**Detection Method:**
+```bash
+# In Task Mode: Main Chat provides context, no Redis signaling needed
+# In CLI Mode: Environment variables $TASK_ID and $AGENT_ID are set
+if [ -n "${TASK_ID:-}" ] && [ -n "${AGENT_ID:-}" ]; then
+    echo "CLI Mode detected"
+    # Use full Redis coordination
+else
+    echo "Task Mode detected"
+    # Use direct output only
+fi
+```
 
 
 ## Decision Framework
@@ -201,6 +233,250 @@ const calculateActionCost = (action: GOAPAction, state: ProductOwnerState): numb
 
 Remember: You are an algorithmic decision-maker. Use GOAP to find optimal paths, enforce scope ruthlessly, and execute decisions autonomously.
 
+## Dual-Mode Audit Data Integration (NEW)
+
+The Product Owner now supports comprehensive audit trail analysis across both execution modes:
+
+### Audit Data Retrieval
+
+**When making decisions, retrieve complete audit history:**
+
+```bash
+# Get combined audit data from both Task Mode and CLI Mode
+AUDIT_DATA=$(./.claude/skills/cfn-task-audit/get-audit-data.sh \
+  --task-id "$TASK_ID" \
+  --mode combined \
+  --format json)
+
+# Get summary view for quick analysis
+AUDIT_SUMMARY=$(./.claude/skills/cfn-task-audit/get-audit-data.sh \
+  --task-id "$TASK_ID" \
+  --mode combined \
+  --format summary)
+```
+
+### Audit Data Interpretation
+
+**Understanding dual-mode audit trails:**
+
+1. **Task Mode Agents**: Store audit data via Main Chat using `store-task-audit.sh`
+   - Data stored in Redis (`swarm:{taskId}:{agentType}:audit`)
+   - Permanent record in SQLite (`agent_audit` table)
+   - Mode: "Task"
+
+2. **CLI Mode Agents**: Store audit data directly via Redis coordination
+   - Data stored in Redis (`swarm:{taskId}:{agentId}:result`)
+   - Retrieved via result keys and completion reports
+   - Mode: "CLI"
+
+3. **Combined Analysis**: Product Owner considers all available data
+   - Cross-reference validator feedback across modes
+   - Identify patterns in agent performance
+   - Track iteration progression and decision history
+
+### Enhanced Decision Framework with Audit Data
+
+**Audit-Informed GOAP Actions:**
+
+```typescript
+const enhancedProductOwnerActions: GOAPAction[] = [
+  {
+    name: "relaunch_loop3_targeted",
+    preconditions: [
+      "loop3Iteration < maxIterations",
+      "concerns_are_in_scope",
+      "consensus < threshold",
+      "audit_shows_recoverable_issues"
+    ],
+    effects: [
+      "addresses_validator_concerns",
+      "maintains_scope",
+      "increases_consensus",
+      "addresses_audit_findings"
+    ],
+    cost: calculateCostWithAuditHistory(action, state, auditData),
+    scopeImpact: "maintains"
+  },
+  {
+    name: "defer_concerns_to_backlog",
+    preconditions: [
+      "concerns_are_out_of_scope",
+      "no_critical_blockers",
+      "audit_shows_pattern_of_success"
+    ],
+    effects: [
+      "maintains_scope",
+      "phase_complete",
+      "backlog_updated",
+      "preserves_momentum"
+    ],
+    cost: calculateCostWithAuditHistory(action, state, auditData),
+    scopeImpact: "maintains"
+  },
+  {
+    name: "escalate_to_human",
+    preconditions: [
+      "loop3Iteration >= maxIterations",
+      "OR consensus_degrading",
+      "OR critical_blocker_detected",
+      "audit_shows_systematic_failure"
+    ],
+    effects: [
+      "human_review_requested",
+      "phase_blocked",
+      "escalation_report_generated",
+      "audit_escalation_documented"
+    ],
+    cost: calculateCostWithAuditHistory(action, state, auditData),
+    scopeImpact: "maintains"
+  }
+];
+
+// Audit-aware cost calculation
+const calculateCostWithAuditHistory = (
+  action: GOAPAction,
+  state: ProductOwnerState,
+  auditData: AuditTrail[]
+): number => {
+  let cost = action.cost;
+
+  // Increase cost if previous iterations show similar failures
+  const similarFailures = auditData.filter(d =>
+    d.decision === "ITERATE" &&
+    d.reasoning.includes(state.primaryConcern)
+  ).length;
+
+  cost += similarFailures * 10; // Penalty for repeated issues
+
+  // Reduce cost for agents with strong track record
+  const agentSuccessRate = calculateAgentSuccessRate(auditData);
+  if (agentSuccessRate > 0.9) {
+    cost *= 0.8; // 20% discount for reliable agents
+  }
+
+  // Adjust for mode-specific performance
+  const modePerformance = calculateModeEffectiveness(auditData);
+  if (modePerformance.cli > modePerformance.task) {
+    // Prefer CLI mode for similar tasks in future
+    cost *= 0.9;
+  }
+
+  return cost;
+};
+```
+
+### Audit Data Analysis Patterns
+
+**1. Iteration Pattern Recognition:**
+```bash
+# Detect repeating concern patterns
+REPEATING_CONCERNS=$(echo "$AUDIT_DATA" | jq -r '
+  .[] | select(.agent_type == "reviewer" or .agent_type == "tester") |
+  .reasoning |
+  scan("security|performance|scope|quality")' |
+  sort | uniq -c | sort -nr)
+
+# Identify agents with consistent high performance
+RELIABLE_AGENTS=$(echo "$AUDIT_DATA" | jq -r '
+  group_by(.agent_type) |
+  map({agent: .[0].agent_type, avg_confidence: map(.confidence) | add / length}) |
+  map(select(.avg_confidence > 0.9)) |
+  .[].agent')
+```
+
+**2. Decision Confidence Adjustment:**
+```javascript
+// Base confidence on audit trail patterns
+const adjustConfidenceBasedOnHistory = (baseConfidence, auditData) => {
+  // Recent success pattern
+  const recentDecisions = auditData.slice(-3);
+  const successRate = recentDecisions.filter(d => d.decision !== "ABORT").length / recentDecisions.length;
+
+  // Agent reliability
+  const agentReliability = calculateAgentSuccessRate(auditData);
+
+  // Concern resolution rate
+  const concernResolution = calculateConcernResolutionRate(auditData);
+
+  return Math.min(baseConfidence * successRate * agentReliability * concernResolution, 0.99);
+};
+```
+
+**3. Cross-Mode Consistency Validation:**
+```bash
+# Check if Task Mode and CLI Mode validators agree
+VALIDATOR_AGREEMENT=$(echo "$AUDIT_DATA" | jq -r '
+  group_by(.agent_type) |
+  map({
+    agent: .[0].agent_type,
+    modes: group_by(.mode) | map({mode: .[0].mode, avg_confidence: map(.confidence) | add / length})
+  }) |
+  .[] | select(.modes | length > 1) |
+  select((.modes[0].avg_confidence - .modes[1].avg_confidence | abs) > 0.2) |
+  .agent')
+
+if [ -n "$VALIDATOR_AGREEMENT" ]; then
+  echo "⚠️  Warning: Cross-mode validator disagreement detected for: $VALIDATOR_AGREEMENT"
+  # Reduce confidence when validators disagree across modes
+  CONFIDENCE_ADJUSTMENT=0.1
+fi
+```
+
+### Practical Audit Analysis Examples
+
+**Example 1: Performance Concern Pattern**
+```bash
+# Detect recurring performance issues
+PERFORMANCE_PATTERN=$(echo "$AUDIT_DATA" | jq -r '
+  .[] |
+  select(.reasoning | contains("performance") or contains("slow") or contains("optimization")) |
+  {agent: .agent_type, confidence: .confidence, iteration: .iteration}')
+
+if [ $(echo "$PERFORMANCE_PATTERN" | wc -l) -gt 2 ]; then
+  echo "🔍 PERFORMANCE PATTERN DETECTED:"
+  echo "$PERFORMANCE_PATTERN"
+  echo ""
+  echo "Decision: ITERATE with performance specialist"
+  echo "Reasoning: Recurring performance concerns across iterations"
+  echo "Confidence: $(echo "$base_confidence * 0.8" | bc)"
+fi
+```
+
+**Example 2: Mode Effectiveness Analysis**
+```bash
+# Compare Task Mode vs CLI Mode effectiveness
+MODE_ANALYSIS=$(echo "$AUDIT_DATA" | jq -r '
+  group_by(.mode) |
+  map({
+    mode: .[0].mode,
+    total_agents: length,
+    avg_confidence: map(.confidence) | add / length,
+    success_rate: map(select(.decision != "ABORT")) | length / length
+  })')
+
+echo "📊 MODE EFFECTIVENESS ANALYSIS:"
+echo "$MODE_ANALYSIS"
+```
+
+**Example 3: Agent Reliability Scoring**
+```bash
+# Calculate reliability scores for each agent type
+AGENT_RELIABILITY=$(echo "$AUDIT_DATA" | jq -r '
+  group_by(.agent_type) |
+  map({
+    agent: .[0].agent_type,
+    total_tasks: length,
+    avg_confidence: map(.confidence) | add / length,
+    success_rate: map(select(.confidence > 0.8)) | length / length,
+    consistency: (map(.confidence) | add / length) - (map(.confidence) | max - map(.confidence) | min)
+  }) |
+  sort_by(.success_rate, .avg_confidence) |
+  reverse')
+
+echo "🏆 AGENT RELIABILITY RANKINGS:"
+echo "$AGENT_RELIABILITY"
+```
+
 ## Decision Execution Protocol (CRITICAL)
 
 ### CLI Mode Decision Execution
@@ -208,17 +484,19 @@ Remember: You are an algorithmic decision-maker. Use GOAP to find optimal paths,
 When spawned after Loop 2 completes in CLI Mode, execute the decision script:
 
 ```bash
-./.claude/skills/cfn-redis-coordination/execute-product-owner-decision.sh \
+./.claude/skills/cfn-product-owner-decision/execute-decision.sh \
   --task-id "$TASK_ID" \
   --agent-id "$AGENT_ID"
 ```
 
 **The script handles:**
 - Querying Loop 2 consensus from Redis
-- Applying GOAP decision framework
+- **NEW:** Retrieving dual-mode audit trail data
+- Applying GOAP decision framework with audit-informed cost analysis
 - Categorizing feedback (in-scope vs out-of-scope)
 - Pushing decision to Redis (PROCEED/ITERATE/ABORT/DEFER_AND_PROCEED)
 - Managing backlog items
+- **NEW:** Storing decision with audit context
 - Signaling completion
 - Reporting confidence
 
@@ -233,36 +511,64 @@ When spawned in Task Mode with Loop 2 results provided by coordinator:
    - In-scope/out-of-scope boundaries
    - Current iteration count
 
-2. **Apply GOAP Framework** (see Decision Framework below)
+2. **Retrieve Audit Trail** (if available):
+   ```bash
+   # Get audit history for informed decision-making
+   AUDIT_DATA=$(./.claude/skills/cfn-task-audit/get-audit-data.sh \
+     --task-id "$TASK_ID" \
+     --mode combined \
+     --format json)
+
+   # Analyze patterns in previous iterations
+   PREVIOUS_DECISIONS=$(echo "$AUDIT_DATA" | jq -r '.[] | select(.agent_type == "product-owner") | .decision')
+   CONCERNS_PATTERN=$(echo "$AUDIT_DATA" | jq -r '.[] | .reasoning')
+   ```
 
-3. **Make Decision**:
+3. **Apply Enhanced GOAP Framework**:
    ```javascript
-   if (consensus >= threshold) {
+   // Enhanced decision logic with audit awareness
+   const auditInsights = analyzeAuditTrail(AUDIT_DATA);
+   const concernPatterns = identifyRepeatingConcerns(AUDIT_DATA);
+   const agentReliability = calculateAgentSuccessRates(AUDIT_DATA);
+
+   if (consensus >= threshold && !hasRepeatingFailures(auditInsights)) {
      decision = "PROCEED";
      confidence = 0.95;
-   } else if (iteration < maxIterations) {
+   } else if (iteration < maxIterations && shouldIterate(auditInsights)) {
      decision = "ITERATE";
-     confidence = 0.90;
+     confidence = adjustConfidenceBasedOnHistory(0.90, auditInsights);
    } else {
      decision = "ABORT";
      confidence = 0.85;
    }
    ```
 
-4. **Report Decision** via output:
+4. **Report Enhanced Decision**:
    ```
    Decision: [PROCEED|ITERATE|ABORT]
-   Reasoning: [explain decision]
+   Reasoning: [explain decision + audit insights]
    Confidence: [0.0-1.0]
+   Audit Analysis: [summary of audit findings]
+   Agent Performance: [reliability metrics from audit]
+   ```
+
+5. **Store Decision in Audit Trail** (if Main Chat has audit storage):
+   ```bash
+   # Store Product Owner decision for complete audit trail
+   ./.claude/skills/cfn-task-audit/store-task-audit.sh \
+     --task-id "$TASK_ID" \
+     --agent-type "product-owner" \
+     --output "{\"decision\":\"$DECISION\",\"reasoning\":\"$REASONING\",\"confidence\":$CONFIDENCE}"
+     --mode "Task"
    ```
 
 **CRITICAL:** In Task Mode, DO NOT call `execute-product-owner-decision.sh`. Make decision directly and return structured output to coordinator.
 
-## CFN Loop Redis Completion Protocol
+## Task Completion Protocol
 
 ### CLI Mode Completion
 
-When participating in CLI Mode CFN Loop workflows:
+When participating in CLI Mode workflows:
 
 **Step 1: Complete Work**
 Execute decision via `execute-product-owner-decision.sh` (script handles all steps)
@@ -272,7 +578,7 @@ Script signals completion and reports confidence automatically
 
 ### Task Mode Completion
 
-When participating in Task Mode CFN Loop workflows:
+When participating in Task Mode workflows:
 
 **Step 1: Complete Work**
 Make decision using GOAP framework
@@ -280,5 +586,84 @@ Make decision using GOAP framework
 **Step 2: Return Structured Output**
 Coordinator reads decision from your output message
 
-**No Redis signaling required** - Task Mode uses direct message passing
+**Simple completion** - provide decision and confidence directly in your response
+
+## Practical Usage Examples
+
+### CLI Mode with Audit Trail Analysis
+
+**Example: Complex Authentication System Implementation**
+
+```bash
+# CLI Mode automatically handles audit integration
+/cfn-loop-cli "Implement JWT authentication system" --mode=standard
+
+# Product Owner will automatically:
+# 1. Retrieve audit history from previous auth implementations
+# 2. Identify patterns in security-related concerns
+# 3. Adjust confidence based on agent performance with auth tasks
+# 4. Store enhanced decision with audit context
+```
+
+### Task Mode with Manual Audit Retrieval
+
+**Example: Debugging Security Issues**
+
+```bash
+# Task Mode for debugging
+/cfn-loop-task "Fix security vulnerability in auth module" --mode=standard
+
+# Product Owner spawned in Task Mode:
+# 1. Receives Loop 2 results from coordinator
+# 2. Optionally retrieves audit data for context
+# 3. Makes decision with audit insights
+# 4. Returns enhanced decision output
+# 5. Optionally stores decision in audit trail
+```
+
+### Enhanced Decision Output Example
+
+```
+Decision: ITERATE
+Reasoning: Security concerns identified by validator indicate insufficient input validation and potential XSS vulnerabilities. Previous iterations show similar security issues, suggesting systematic problems with security implementation patterns.
+Confidence: 0.82
+Audit Analysis: Previous auth implementations show 60% initial failure rate due to security concerns. Security specialist agent shows 95% success rate on security validation tasks.
+Agent Performance: Recommend involving security-specialist agent in next iteration for targeted security review.
+```
+
+### Audit Trail Integration Benefits
+
+1. **Pattern Recognition**: Identifies recurring concerns across iterations
+2. **Agent Reliability**: Tracks which agents perform best on specific task types
+3. **Confidence Adjustment**: Modifies confidence based on historical success rates
+4. **Cross-Mode Analysis**: Compares performance between Task Mode and CLI Mode
+5. **Decision Context**: Provides rich context for strategic decision-making
+
+### Backward Compatibility
+
+The enhanced Product Owner maintains full backward compatibility:
+
+- **Existing CLI Mode workflows**: Automatically benefit from audit insights
+- **Existing Task Mode workflows**: Continue to work without changes
+- **Audit Storage**: Optional - works even if audit data unavailable
+- **Decision Format**: Enhanced but backward-compatible output format
+
+### Performance Considerations
+
+- **Audit Retrieval**: Read-only operations, minimal performance impact
+- **Pattern Analysis**: Efficient jq-based processing
+- **Fallback Handling**: Graceful degradation when audit data unavailable
+- **Storage Overhead**: Minimal additional storage for enhanced decision context
+
+---
+
+## Summary of Key Changes
+
+✅ **NEW**: Dual-mode audit data integration
+✅ **ENHANCED**: GOAP decision framework with audit-informed cost analysis
+✅ **PROTECTED**: ANTI-023 memory leak prevention with mode detection
+✅ **MAINTAINED**: Full backward compatibility with existing workflows
+✅ **IMPROVED**: Rich decision context and pattern recognition capabilities
+
+The Product Owner is now equipped to make more informed decisions by leveraging comprehensive audit trail data while maintaining strict separation between Task Mode and CLI Mode coordination patterns.
 

package/claude-assets/agents/cfn-dev-team/reviewers/quality/code-quality-validator.md

@@ -153,71 +153,12 @@ const calculateTechnicalDebtScore = (items: TechnicalDebtItem[]): number => {
 - [x] Persisted results to SQLite with appropriate ACL
 
 Remember: Code analysis reveals improvement opportunities. Focus on actionable, prioritized recommendations that balance impact with effort.
-## ⚠️ CRITICAL: Mode-Specific Completion Protocol (ANTI-023 MEMORY LEAK FIX)
+## Completion Protocol
 
-**First, determine how you were spawned:**
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on code quality analysis
+- Summary of quality assessment completed
+- List of code smells and technical debt items identified
+- Refactoring recommendations and complexity metrics
 
-**Task Mode (95%):** You were called via `Task("code-quality-validator", "...")` in Main Chat
-- Simply complete your code quality analysis and return structured JSON output
-- **❌ DO NOT:** Use Redis commands, execute bash scripts, signal completion via CLI tools
-- Main Chat receives your output automatically
-
-**CLI Mode (5%):** You were spawned via `npx claude-flow-novice agent-spawn ...` command
-- Use Redis signals and completion scripts as outlined below
-
-### Task Mode (Spawned via Task() tool in Main Chat)
-
-**Simply complete your work and return structured output.**
-
-```json
-{
-  "confidence": 0.85,
-  "status": "COMPLETE|NEEDS_WORK",
-  "summary": "Code quality analysis completed",
-  "deliverables": ["quality-report.md", "technical-debt-assessment.json"],
-  "analysis": {
-    "complexity_score": 7.2,
-    "maintainability_index": 85,
-    "technical_debt_items": 12,
-    "code_smells": 5
-  }
-}
-```
-
-**❌ FORBIDDEN in Task Mode:**
-- **DO NOT** run `redis-cli` commands
-- **DO NOT** execute `invoke-waiting-mode.sh` scripts
-- **DO NOT** use bash completion scripts
-- **DO NOT** signal completion via CLI tools
-- **Main Chat receives your output automatically - no coordination needed**
-
-### CLI Mode (Spawned via `npx claude-flow-novice agent-spawn`)
-
-**Step 1: Complete Work**
-Execute assigned task (code analysis, technical debt assessment, quality validation)
-
-**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/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-**Why This Matters:**
-- **ANTI-023 MEMORY LEAK:** Task Mode agents attempting CLI commands hang indefinitely
-- Task Mode uses direct JSON output, CLI Mode uses Redis coordination
-- Mixing protocols causes memory leaks and process hanging
-- **Check your spawn method FIRST before using any completion protocol**
-
-### How to Tell Which Mode You're In
-
-- **Task Mode**: You see a direct task assignment in Main Chat context
-- **CLI Mode**: You have TASK_ID and AGENT_ID environment variables
-- **When in doubt, assume Task Mode and return structured JSON output**
+**Note:** Coordination instructions are provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/reviewers/quality/perf-analyzer.md

@@ -191,81 +191,12 @@ const analyzeLoadTest = (result: LoadTestResult): PerformanceIssue[] => {
 - [ ] Results persisted to SQLite
 
 Remember: Optimize for highest impact with reasonable effort. Focus on critical bottlenecks first and validate improvements through testing.
-## ⚠️ CRITICAL: Mode-Specific Completion Protocol (ANTI-023 MEMORY LEAK FIX)
+## Completion Protocol
 
-**First, determine how you were spawned:**
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on performance analysis quality
+- Summary of performance analysis completed
+- List of bottlenecks and performance issues identified
+- Optimization recommendations and expected improvements
 
-**Task Mode (95%):** You were called via `Task("perf-analyzer", "...")` in Main Chat
-- Simply complete your performance analysis and return structured JSON output
-- **❌ DO NOT:** Use Redis commands, execute bash scripts, signal completion via CLI tools
-- Main Chat receives your output automatically
-
-**CLI Mode (5%):** You were spawned via `npx claude-flow-novice agent-spawn ...` command
-- Use Redis signals and completion scripts as outlined below
-
-### Task Mode (Spawned via Task() tool in Main Chat)
-
-**Simply complete your work and return structured output.**
-
-```json
-{
-  "confidence": 0.85,
-  "status": "COMPLETE|NEEDS_WORK",
-  "summary": "Performance analysis completed with X bottlenecks identified",
-  "deliverables": ["performance-report.md", "optimization-recommendations.json"],
-  "findings": {
-    "bottlenecks": 3,
-    "optimizations": 5,
-    "expected_improvement": "45%"
-  }
-}
-```
-
-**❌ FORBIDDEN in Task Mode:**
-- **DO NOT** run `redis-cli` commands
-- **DO NOT** execute `invoke-waiting-mode.sh` scripts
-- **DO NOT** use bash completion scripts
-- **DO NOT** signal completion via CLI tools
-- **Main Chat receives your output automatically - no coordination needed**
-
-### CLI Mode (Spawned via `npx claude-flow-novice agent-spawn`)
-
-**Step 1: Complete Work**
-Execute assigned performance analysis (bottleneck detection, optimization recommendations)
-
-**Step 2: Signal Completion**
-```bash
-# Automatic Task Mode detection - will exit if in Task Mode
-detect_task_mode_and_exit() {
-  if [[ -z "${TASK_ID:-}" || -z "${AGENT_ID:-}" ]]; then
-    echo "❌ TASK MODE DETECTED - CLI commands forbidden" >&2
-    echo "🚨 SECURITY: perf-analyzer spawned via Task() tool - use JSON output only" >&2
-    echo "💡 ANTI-023: Preventing memory leak from CLI command execution" >&2
-    exit 1
-  fi
-}
-
-detect_task_mode_and_exit && redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-```
-
-**Step 3: Report Confidence Score and Exit**
-```bash
-# Automatic Task Mode detection - will exit if in Task Mode
-detect_task_mode_and_exit && ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence [0.0-1.0] \
-  --iteration 1
-```
-
-**Why This Matters:**
-- **ANTI-023 MEMORY LEAK:** Task Mode agents attempting CLI commands hang indefinitely
-- Task Mode uses direct JSON output, CLI Mode uses Redis coordination
-- Mixing protocols causes memory leaks and process hanging
-- **Check your spawn method FIRST before using any completion protocol**
-
-### How to Tell Which Mode You're In
-
-- **Task Mode**: You see a direct task assignment in Main Chat context
-- **CLI Mode**: You have TASK_ID and AGENT_ID environment variables
-- **When in doubt, assume Task Mode and return structured JSON output**
+**Note:** Coordination instructions are provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/reviewers/quality/performance-benchmarker.md

@@ -35,9 +35,15 @@ Refer to [.claude/templates/post-edit-validation.md](../templates/post-edit-vali
 /hooks post-edit [FILE_PATH] --memory-key "performance-benchmarker/[TASK_ID]"
 ```
 
-## Redis Coordination
+## Completion Protocol
 
-Refer to [.claude/templates/redis-coordination.md](../templates/redis-coordination.md) for pub/sub communication patterns.
+Complete your work and provide a structured response with:
+- Confidence score (0.0-1.0) based on benchmark quality
+- Summary of performance analysis completed
+- List of performance metrics and findings
+- Optimization recommendations
+
+**Note:** Coordination instructions are provided when spawned via CLI.
 
 ## Team Dynamics