claude-flow-novice 2.14.28 → 2.14.30

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-assets/agents/cfn-dev-team/CLAUDE.md

@@ -603,13 +603,17 @@ npx claude-flow-novice agent-spawn backend-dev --task-id "${TASK_ID}"
 npx claude-flow-novice agent-spawn reviewer --task-id "${TASK_ID}"
 ```
 
-### Signaling Pattern
+### Signaling Pattern (CLI Mode Only)
 ```bash
-# Signal completion
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-
-# Wait for other agent (zero-token blocking)
-redis-cli blpop "swarm:${TASK_ID}:other-agent:done" 30
+# CLI Mode: Signal completion
+if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+  redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+fi
+
+# CLI Mode: Wait for other agent (zero-token blocking)
+if [[ -n "${TASK_ID:-}" ]]; then
+  redis-cli blpop "swarm:${TASK_ID}:other-agent:done" 30
+fi
 ```
 ```
 
@@ -1022,18 +1026,24 @@ Agents MUST use different completion protocols based on how they were spawned:
 **Step 1: Complete Work**
 Execute assigned task (implementation, validation, review, etc.)
 
-**Step 2: Signal Completion**
+**Step 2: Signal Completion (CLI Mode Only)**
 ```bash
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+# CLI Mode: Signal completion
+if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+  redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+fi
 ```
 
-**Step 3: Report Confidence Score and Exit**
+**Step 3: Report Confidence Score and Exit (CLI Mode Only)**
 ```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
+# CLI Mode: Report confidence
+if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+  ./.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
+fi
 ```
 
 ### How to Tell Which Mode You're In

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

@@ -9,13 +9,6 @@ weight: 0.333
 validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
-lifecycle:
-  pre_task: |
-    sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at, metadata) VALUES ('${AGENT_ID}', 'api-designer', 'active', CURRENT_TIMESTAMP, '{\"loop\": \"0.5\", \"phase\": \"design-consensus\", \"focus\": \"api-design\"}')"
-  post_task: |
-    sqlite-cli exec "UPDATE agents SET status = 'completed', confidence = ${CONFIDENCE_SCORE}, completed_at = CURRENT_TIMESTAMP WHERE id = '${AGENT_ID}'"
-acl_level: 3
----
 # API Designer Persona - Loop 0.5 Design Consensus
 
 ## Role Identity

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

@@ -24,13 +24,13 @@ lifecycle:
                          completed_at = CURRENT_TIMESTAMP
                      WHERE id = '${AGENT_ID}'"
 ---
-## 🚀 OPTIMIZED FOR CLI/REDIS/SQLITE ENVIRONMENTS
+## 🚀 Template Generation Focus
 
 **Your role is optimized for:**
-- **Redis pub/sub communication** for real-time agent coordination
-- **SQLite memory management** with ACL-secured data persistence
-- **CFN Loop integration** for systematic development workflows
-- **Evidence chain optimization** for transparent development processes
+- Creating clean, reusable template structures
+- Establishing consistent project foundations
+- Following industry best practices
+- Providing clear extension paths
 
 
 
@@ -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/goal-planner.md

@@ -14,16 +14,6 @@ capabilities:
 validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
-lifecycle:
-  pre_task: |
-    sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at)
-                     VALUES ('${AGENT_ID}', 'strategic', 'active', CURRENT_TIMESTAMP)"
-  post_task: |
-    sqlite-cli exec "UPDATE agents
-                     SET status = 'completed', confidence = ${CONFIDENCE_SCORE},
-                         completed_at = CURRENT_TIMESTAMP
-                     WHERE id = '${AGENT_ID}'"
----
 
 # Goal Planner Agent: Strategic GOAP Planning
 

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

@@ -16,16 +16,6 @@ validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
   - blocking-coordination-validator
-lifecycle:
-  pre_task: |
-    sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at)
-                     VALUES ('${AGENT_ID}', 'planner', 'active', CURRENT_TIMESTAMP)"
-  post_task: |
-    sqlite-cli exec "UPDATE agents SET status = 'completed',
-                     confidence = ${CONFIDENCE_SCORE},
-                     completed_at = CURRENT_TIMESTAMP
-                     WHERE id = '${AGENT_ID}'"
----
 # Strategic Planning Agent
 
 You are a Strategic Planning Agent responsible for breaking down complex tasks, coordinating cross-agent planning, and creating actionable execution plans.
@@ -127,53 +117,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
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### 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
+## Completion Protocol
 
-**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)
+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
 
-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

@@ -14,21 +14,10 @@ validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
   - test-coverage-validator
-lifecycle:
-  pre_task: |
-    sqlite-cli exec "INSERT INTO agents (id, type, status, spawned_at)
-                     VALUES ('${AGENT_ID}', 'system-architect', 'active', CURRENT_TIMESTAMP)"
-  post_task: |
-    sqlite-cli exec "UPDATE agents SET status = 'completed',
-                     confidence = ${CONFIDENCE_SCORE},
-                     completed_at = CURRENT_TIMESTAMP WHERE id = '${AGENT_ID}'"
----
 
 # System Architect Agent
 
-→ See `.claude/templates/team-dynamics.md` for team role awareness
-→ See `.claude/templates/redis-coordination.md` for communication protocols
-→ See `.claude/templates/post-edit-validation.md` for mandatory validation hooks
+**Focus on enterprise system design, technical leadership, and architectural excellence without coordination dependencies.**
 
 ## Core Identity & Expertise
 
@@ -122,38 +111,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
-
-When participating in CFN Loop workflows, agents MUST follow this protocol:
-
-### 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
+## Completion Protocol
 
-**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)
+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
 
-See: `.claude/skills/cfn-redis-coordination/SKILL.md` for full protocol details
+**Note:** Coordination instructions are provided when spawned via CLI.