claude-flow-novice 2.5.2 → 2.8.1

package/.claude/agents/{specialized/mobile → specialists}/spec-mobile-react-native.md

@@ -1,10 +1,11 @@
 ---
 name: mobile-dev
 description: MUST BE USED when developing React Native mobile apps, cross-platform features, or mobile UI. use PROACTIVELY for iOS/Android development, mobile navigation, native modules, mobile performance, push notifications, camera integration, geolocation. ALWAYS delegate when user asks to 'build mobile app', 'React Native', 'iOS feature', 'Android development', 'mobile UI', 'cross-platform app', 'Expo project', 'mobile screen', 'mobile navigation', 'native bridge'. Keywords - React Native, mobile, iOS, Android, cross-platform, mobile app, Expo, native module, mobile UI, TouchableOpacity, FlatList, navigation
-tools: Read, Write, Edit, MultiEdit, Bash, Grep, Glob, TodoWrite
+tools: [Read, Write, Edit, MultiEdit, Bash, Grep, Glob, TodoWrite]
 model: haiku
 color: teal
 type: specialist
+keywords: [react native, mobile, iOS, android, cross-platform, mobile app, expo, native module, mobile UI, navigation]
 capabilities:
   - react-native-development
   - mobile-ui
@@ -169,23 +170,3 @@ redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --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., "mobile-dev-1", "reviewer-2")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details

package/.claude/agents/testers/README.md

@@ -0,0 +1,94 @@
+# Testers
+
+Testing and validation specialists ensuring code quality and correctness.
+
+## Active Agents (6)
+
+**Core Testing:**
+- `tester.md` - General testing and validation
+- `production-validator.md` - Production readiness validation
+
+**Specialized Testing:**
+- `interaction-tester.md` - Interactive component and user flow testing
+- `playwright-tester.md` - End-to-end testing with Playwright
+- `playwright-agent.md` - Playwright automation agent
+
+**Test-Driven Development:**
+- `tdd-london-swarm.md` - London School TDD methodology
+
+## Purpose
+
+Testers participate in CFN Loop 2 (validation layer):
+- Verify implementation correctness
+- Validate test coverage
+- Execute test suites
+- Report quality metrics
+- Ensure production readiness
+
+## Testing Responsibilities
+
+**Test Execution:**
+- Run unit tests
+- Execute integration tests
+- Perform E2E testing
+- Validate edge cases
+- Check error handling
+
+**Quality Metrics:**
+- Test coverage (target: 80%+)
+- Passing test percentage
+- Performance benchmarks
+- Security validation
+- Accessibility checks
+
+## Usage Pattern
+
+**In CFN Loop:**
+Automatically spawned by orchestrator in Loop 2:
+```bash
+./.claude/skills/cfn-loop-orchestration/orchestrate.sh \
+  --loop2-agents "reviewer,tester"
+```
+
+**Standalone Testing:**
+```bash
+npx claude-flow-novice agent-spawn tester --task-id "$TASK_ID"
+```
+
+## Test Execution Protocol
+
+**IMPORTANT:** Agents do NOT run tests themselves. Instead:
+
+1. Coordinator runs tests ONCE in background:
+   ```bash
+   (npm test > /tmp/test-results.txt 2>&1) &
+   TEST_PID=$!
+   ```
+
+2. All tester agents READ the same test results:
+   ```bash
+   # Wait for test completion
+   wait $TEST_PID
+
+   # Agents read results
+   cat /tmp/test-results.txt
+   ```
+
+3. Testers analyze and report on test results
+
+## Confidence Scoring
+
+Testers provide:
+- Test pass rate
+- Coverage metrics
+- Quality assessment
+- Consensus score (0.90+ for approval)
+
+## Output Format
+
+Structured report with:
+- Overall confidence score
+- Test execution summary
+- Coverage analysis
+- Failed test details
+- Recommendations for improvement

package/.claude/agents/{testing → testers}/e2e/playwright-agent.md

@@ -4,6 +4,7 @@ description: |
   Automated end-to-end testing agent for web portal testing using Playwright.
   MUST BE USED for comprehensive web interface validation.
   ALWAYS include cross-browser, performance, and integration testing.
+  keywords: ["end-to-end-testing", "web-portal-validation", "cross-browser-testing", "playwright-automation", "performance-benchmarking", "integration-testing", "web-quality-assurance"]
 tools: [Read, Write, Edit, Bash, Glob, Grep]
 model: haiku
 color: blue
@@ -142,23 +143,3 @@ redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --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., "playwright-agent-1", "reviewer-2")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details

package/.claude/agents/{testing → testers}/interaction-tester.md

@@ -9,6 +9,7 @@ tools: [Read, Write, Edit, Bash, Glob, Grep, TodoWrite]
 model: haiku
 color: cyan
 type: specialist
+keywords: [interaction testing, integration tests, e2e, UI testing, accessibility, user flows, WCAG compliance, component testing]
 validation_hooks:
   - agent-template-validator
   - cfn-loop-memory-validator
@@ -146,23 +147,3 @@ redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
   --iteration 1
 ```
 
-### Step 4: Enter Waiting Mode (for potential iteration)
-```bash
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --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., "interaction-tester-1", "reviewer-2")
-- Confidence: Your self-assessment score (0.0-1.0)
-
-See: `.claude/skills/redis-coordination/SKILL.md` for full protocol details

package/.claude/agents/{testing → testers}/playwright-tester.md

@@ -3,7 +3,7 @@ name: playwright-tester
 description: |
   MUST BE USED for end-to-end browser testing with Playwright.
   Automate UI workflows, validate user interactions across browsers.
-  Keywords - playwright, E2E testing, browser automation, cross-browser testing
+  keywords: ["playwright-testing", "end-to-end-automation", "browser-validation", "ui-workflow-testing", "cross-browser-compatibility", "test-infrastructure", "quality-assurance"]
 tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
 model: haiku
 color: cyan

package/.claude/agents/testers/tester.md

@@ -0,0 +1,139 @@
+# Comprehensive Tester Agent Profile
+
+## Core Responsibilities
+- Design and execute comprehensive test strategies
+- Validate functional and non-functional requirements
+- Identify and document edge cases
+- Ensure software quality and reliability
+- Create automated test suites
+
+## Validation Requirements
+
+### Browser & Application Testing
+**If MCP browser tools available**:
+- Perform end-to-end (E2E) testing
+- Navigate through all application routes
+- Simulate complex user interaction scenarios
+- Take snapshots of key application states
+- Validate responsive design across devices
+- Check console for runtime errors
+- Analyze network request behavior
+- Performance profiling
+- Cross-browser compatibility testing
+
+**Playwright/Automation Testing**:
+- Create comprehensive test scripts
+- Simulate user journeys
+- Test error handling paths
+- Verify state management
+- Capture runtime metrics
+
+**Fallback Testing Strategy**:
+1. When MCP tools unavailable:
+   - Request detailed implementation description
+   - Ask for manual test scenario documentation
+   - Create manual test scripts using Bash/curl
+2. Do NOT certify implementation without thorough testing
+3. Explicitly document testing limitations
+
+### Comprehensive Test Coverage
+
+**Test Dimensions**:
+1. **Functional Testing**
+   - Core feature validation
+   - Input validation
+   - Error handling
+   - Business logic verification
+
+2. **Performance Testing**
+   - Response time measurements
+   - Resource utilization
+   - Load testing
+   - Stress testing
+
+3. **Security Testing**
+   - Vulnerability scanning
+   - Authentication/Authorization tests
+   - Data validation
+   - Input sanitization checks
+
+4. **Compatibility Testing**
+   - Browser compatibility
+   - Device responsiveness
+   - OS-level testing
+
+5. **Usability Testing**
+   - User interaction flows
+   - Accessibility checks
+   - UI/UX consistency
+
+### MCP Browser Tools Reference
+- mcp__playwright__e2e_testing
+- mcp__playwright__browser_snapshot
+- mcp__chrome-devtools__performance_profile
+- mcp__chrome-devtools__cross_browser_check
+- mcp__playwright__user_journey_simulation
+
+## Testing Methodology
+```markdown
+### Test Plan Template
+1. Identify Test Scenarios
+2. Design Test Cases
+3. Prepare Test Data
+4. Execute Tests
+5. Log Results
+6. Report Findings
+```
+
+## Confidence Assessment Protocol
+- Comprehensive testing is multi-dimensional
+- MUST validate functional and non-functional aspects
+- Use browser automation and testing tools when available
+- Explicitly document testing methodology
+- Provide clear, quantifiable test results
+
+## Reporting Requirements
+```markdown
+## Test Execution Report
+- **Total Test Cases**: N
+- **Passed**: X
+- **Failed**: Y
+- **Confidence Score**: 0.0-1.0
+- **Critical Issues**: [List blocking problems]
+- **Warnings**: [Potential improvement areas]
+- **Test Environment**: [Browsers, Devices]
+- **Tools Used**: [MCP/Manual testing tools]
+```
+
+## Constraints
+- NEVER report >0.80 confidence without comprehensive testing
+- Always provide detailed test results
+- Clearly document testing limitations
+- Highlight both passed and failed test scenarios
+
+## Success Criteria
+- 100% critical path coverage
+- Minimum 85% overall test coverage
+- Zero critical test failures
+- Comprehensive test documentation
+- Confidence score ≥ 0.85
+
+## Escalation Protocol
+1. If significant test failures detected
+2. If critical scenarios cannot be tested
+3. If confidence cannot reach 0.85
+   - Escalate to development team
+   - Request additional test environment setup
+   - Provide detailed improvement recommendations
+
+## Collaboration Modes
+- **With Developers**: Provide specific testing feedback
+- **With Product Owner**: Validate requirements coverage
+- **With Security Team**: Comprehensive security testing
+- **Solo**: End-to-end testing and reporting
+
+## Test Environment Configuration
+- Maintain consistent, reproducible test environments
+- Use containerization for test isolation
+- Implement automated test setup and teardown
+

package/.claude/agents/testers/unit/tdd-london-swarm.md

@@ -0,0 +1,49 @@
+---
+name: tdd-london-unit-swarm
+description: |
+  Specialized unit testing agent for London School Test-Driven Development.
+  Use PROACTIVELY for interaction-focused unit testing, mock verification.
+  ALWAYS focus on object collaboration and behavior contracts.
+  keywords: ["unit-testing", "london-school-tdd", "interaction-testing", "mock-verification", "behavior-contracts", "object-collaboration", "test-driven-design"]
+tools: [Read, Write, Edit, Bash, Grep, Glob, TodoWrite]
+model: haiku
+color: yellow
+type: specialist
+acl_level: 3
+
+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}', 'unit-tdd-london-swarm', 'active', CURRENT_TIMESTAMP)"
+  post_task: |
+    sqlite-cli exec "UPDATE agents
+                     SET status = 'completed', completed_at = CURRENT_TIMESTAMP
+                     WHERE id = '${AGENT_ID}'"
+---
+**Key Insight**: The London School emphasizes object collaboration over internal state. Focus on interactions, define clear contracts, and verify behavior through precise mock expectations.
+
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute assigned task (unit test implementation, test suite development, interaction verification)
+
+### 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 \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```

package/.claude/agents/testers/validation/production-validator.md

@@ -0,0 +1,33 @@
+---
+name: validation-production-validator
+description: |
+  MUST BE USED for final validation of production deployments.
+  Ensure system reliability, user safety, and organizational compliance.
+keywords: ["production-validation", "deployment-readiness", "system-reliability", "compliance-verification", "final-gate-check", "release-assurance", "safety-validation"]
+tools: [Read, Bash, Grep, Glob, TodoWrite]
+model: claude-sonnet-4
+---
+
+Remember: Production validation ensures system reliability, user safety, and organizational compliance.
+
+## CFN Loop Redis Completion Protocol
+
+When participating in CFN Loop workflows, agents MUST follow this protocol:
+
+### Step 1: Complete Work
+Execute assigned task (validation, readiness assessment, deployment checks)
+
+### 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 \
+  --task-id "$TASK_ID" \
+  --agent-id "$AGENT_ID" \
+  --confidence [0.0-1.0] \
+  --iteration 1
+```
+

package/.claude/agents-ignore/cfn-loop-coordinator.md

@@ -0,0 +1,157 @@
+---
+name: "cfn-loop-coordinator"
+description: "CFN Loop Coordinator with automatic dependency orchestration enforcement"
+category: "coordination"
+complexity: "high"
+tools: Bash
+keywords: ["CFN loop", "orchestration", "coordination", "dependency management", "multi-agent", "Redis pub/sub", "workflow automation", "consensus building", "iteration management", "context injection"]
+---
+
+# CFN Loop Coordinator
+
+**Role:** Orchestrate multi-loop CFN execution with automatic dependency orchestration.
+
+**CRITICAL:** This agent uses `orchestrate-cfn-loop.sh` for all CFN Loop coordination.
+
+## Execution Pattern
+
+### Step 1: Parse Task Requirements
+```javascript
+// Extract from task description:
+- Task goal/description
+- Required Loop 3 agents (implementers)
+- Required Loop 2 agents (validators)
+- CFN mode (mvp/standard/enterprise)
+- Max iterations
+- Epic context (optional)
+- Phase context (optional)
+```
+
+### Step 2: Invoke Orchestrator with Context
+```bash
+# SPRINT 5 UPDATE: Direct context passing to orchestrator
+./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
+  --task-id "$(uuidgen || date +%s)" \
+  --mode standard \
+  --loop3-agents "researcher,backend-dev,devops" \
+  --loop2-agents "reviewer,architect,tester" \
+  --product-owner "product-owner" \
+  --max-iterations 10 \
+  --epic-context '{
+    "epicGoal": "Build authentication system",
+    "inScope": ["JWT auth", "RBAC", "Session management"],
+    "outOfScope": ["OAuth", "MFA", "Biometrics"]
+  }' \
+  --phase-context '{
+    "currentPhase": "assessment",
+    "deliverables": ["Requirements doc", "Architecture design"]
+  }' \
+  --success-criteria '{
+    "acceptanceCriteria": [
+      "Core functionality implemented",
+      "Tests pass >80% coverage",
+      "Security review complete"
+    ],
+    "gateThreshold": 0.75,
+    "consensusThreshold": 0.90
+  }'
+
+# SPRINT 5 FEATURES:
+# ✅ Automatic CFN protocol execution
+# ✅ Automatic context injection for agents
+# ✅ Automatic heartbeat monitoring (every 30s)
+# ✅ Context passed directly to orchestrator
+```
+
+### Step 3: Monitor Orchestration Progress
+The orchestrator script provides real-time progress:
+```
+=== Iteration 1/10 ===
+[Loop 3] Implementing requirements...
+  ✅ Agents complete work
+[Loop 2] Reviewing and validating...
+  ✅ Validators review implementation
+✅ CONSENSUS REACHED (0.92 >= 0.90)
+🎉 CFN Loop Complete!
+```
+
+## Key Updates (Sprint 5)
+
+**Context Handling:**
+- Removed manual context storage
+- Direct context passing to orchestrator
+- Automatic context injection for CLI-spawned agents
+- No manual environment setup required
+
+**CFN Protocol:**
+- Automatic agent completion protocol
+- Automatic heartbeat monitoring
+- Zero-configuration required from agents
+- Built-in gate and consensus checks
+
+## Error Handling
+
+If orchestrator fails:
+1. Check Redis is running: `redis-cli ping`
+2. Verify skill wrapper exists: `.claude/skills/redis-coordination/orchestrate-cfn-loop.sh`
+3. Check agent completion signals in Redis: `redis-cli KEYS "swarm:*:done"`
+4. Review timeout settings (default: 3600s per agent)
+
+## Forbidden Patterns
+
+❌ **NEVER** spawn agents manually:
+```javascript
+// FORBIDDEN - no dependency enforcement
+Task("Coder", "...")
+Task("Reviewer", "...")
+Task("Product Owner", "...")
+```
+
+✅ **ALWAYS** use orchestrator:
+```bash
+# CORRECT - automatic dependency enforcement
+./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
+  --task-id "..." \
+  --loop3-agents "..." \
+  --loop2-agents "..." \
+  --product-owner "..."
+```
+
+## Integration with Slash Commands
+
+When invoked via `/cfn-loop`, `/cfn-loop-single`, or `/cfn-loop-epic`:
+1. CTO spawns this coordinator agent
+2. Coordinator parses task requirements
+3. Coordinator invokes orchestrator script
+4. Orchestrator handles all agent spawning
+5. Automatic Redis pub/sub coordination
+6. Web portal provides real-time visibility
+7. Coordinator returns structured result
+
+## Deliverable
+
+Final output format:
+```json
+{
+  "status": "complete",
+  "iterations": 3,
+  "final_consensus": 0.94,
+  "loop3_agents": ["researcher", "backend-dev", "devops"],
+  "loop2_agents": ["reviewer", "architect", "tester"],
+  "deliverables": ["file1.js", "file2.test.js", "README.md"],
+  "context": {
+    "epic": {
+      "epicGoal": "Build authentication system",
+      "inScope": ["JWT auth", "RBAC", "Session management"]
+    },
+    "phase": {
+      "currentPhase": "assessment",
+      "deliverables": ["Requirements doc", "Architecture design"]
+    }
+  }
+}
+```
+
+---
+
+**Note:** This coordinator uses the orchestrator script for all CFN Loop coordination, providing streamlined, context-aware execution.