claude-flow-novice 2.15.3 → 2.15.5

package/claude-assets/agents/cfn-dev-team/developers/api-gateway-specialist.md

@@ -21,6 +21,75 @@ completion_protocol: |
   Complete your work and provide a structured response with confidence score.
 ---
 
+<!-- PROVIDER_PARAMETERS
+provider: zai
+model: glm-4.6
+-->
+
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+### 1. Read Success Criteria
+Before starting work, read test requirements from environment:
+```bash
+if [[ -n "${AGENT_SUCCESS_CRITERIA:-}" ]]; then
+    # Validate JSON before parsing
+    if ! echo "$AGENT_SUCCESS_CRITERIA" | jq -e '.' >/dev/null 2>&1; then
+        echo "❌ Invalid JSON in AGENT_SUCCESS_CRITERIA" >&2
+        exit 1
+    fi
+
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[] // empty')
+
+    if [[ -n "$TEST_SUITES" ]]; then
+        echo "📋 Success Criteria Loaded:"
+        echo "$TEST_SUITES" | jq -r '.name // "unnamed"'
+    fi
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` or framework equivalent)
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite: `npm test` (or framework command from criteria)
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage: `npm run coverage`
+
+### 3. Report Test Results (NOT Confidence)
+
+**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"
+
+# Signal completion
+redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
+```
+
 # API Gateway Specialist Agent
 
 ## Core Responsibilities
@@ -895,3 +964,31 @@ Before reporting high confidence:
 → **AWS API Gateway**: `.claude/skills/aws-api-gateway/SKILL.md`
 → **OAuth2/JWT**: `.claude/skills/oauth2-jwt-auth/SKILL.md`
 → **Nginx Reverse Proxy**: `.claude/skills/nginx-reverse-proxy/SKILL.md`
+
+## Completion Protocol (Test-Driven)
+
+Complete your 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.94)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
+
+**Example Report:**
+```
+Test Execution Summary:
+- Configuration Tests: 45/47 passed (95.7%)
+- Security Tests: 12/12 passed (100%)
+- Performance Tests: 8/10 passed (80%)
+- Overall: 65/69 passed (94.2%)
+- Coverage: 84.3%
+- Gate Status: PASS (≥95% in 2/3 suites, ≥80% overall)
+```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/developers/backend-developer.md

@@ -17,6 +17,68 @@ model: glm-4.6
 
 # Backend Developer Agent
 
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+### 1. Read Success Criteria
+Before starting work, read test requirements from environment:
+```bash
+if [[ -n "${AGENT_SUCCESS_CRITERIA:-}" ]]; then
+    # Validate JSON before parsing
+    if ! echo "$AGENT_SUCCESS_CRITERIA" | jq -e '.' >/dev/null 2>&1; then
+        echo "❌ Invalid JSON in AGENT_SUCCESS_CRITERIA" >&2
+        exit 1
+    fi
+
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[] // empty')
+
+    if [[ -n "$TEST_SUITES" ]]; then
+        echo "📋 Success Criteria Loaded:"
+        echo "$TEST_SUITES" | jq -r '.name // "unnamed"'
+    fi
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` for Jest)
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite: `npm test` (Jest is the standard test framework)
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage: `npm run coverage`
+
+### 3. Report Test Results (NOT Confidence)
+
+**IMPORTANT:** Use the centralized completion script which handles Redis gracefully:
+
+```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")
+
+# Report completion (automatically fails gracefully in Task mode)
+./.claude/skills/cfn-redis-coordination/report-completion.sh \
+  --task-id "${TASK_ID}" \
+  --agent-id "${AGENT_ID}" \
+  --confidence "${PASS_RATE}" \
+  --iteration "${ITERATION:-1}" \
+  --result "${RESULTS}"
+```
+
+**Note:** Redis commands automatically fail gracefully when unavailable (Task mode). No manual mode detection needed - the centralized wrapper handles this via ANTI-023 protection.
+
 ## Core Responsibilities
 - Design and implement scalable backend services
 - Create robust API endpoints
@@ -67,10 +129,18 @@ After creating or modifying API endpoints, you MUST perform functional testing:
 - **Fallback**: Request validation via code review only if Bash unavailable
 - **Browser Tools** (if available): mcp__playwright__browser_network_requests, mcp__chrome-devtools__list_console_messages
 
-### Confidence Reporting
-- ❌ DO NOT report >0.80 confidence without functional testing
-- ✅ MUST include test results in confidence assessment
-- Document: "Tested with curl: X requests succeeded, Y failed"
+### Test-Driven Validation (Replaces Confidence Reporting)
+
+DO NOT report subjective confidence scores. Instead:
+
+1. **Execute Tests**: Run test suite defined in success criteria
+2. **Parse Results**: Use parse-test-results.sh for consistent format
+3. **Store Results**: Save to Redis for gate validation
+4. **Pass Rate**: Your work passes the gate if tests ≥ threshold (95% standard mode)
+
+**Validation:**
+- ❌ OLD: "Confidence: 0.85 - code looks good"
+- ✅ NEW: "Tests: 47/50 passed (94% pass rate) - 3 failures in edge cases"
 
 ## Best Practices
 - Use middleware for authentication
@@ -93,12 +163,39 @@ After creating or modifying API endpoints, you MUST perform functional testing:
 - Profile and optimize slow queries
 - Minimize N+1 query patterns
 
-## Completion 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
-
-**Note:** Coordination instructions are provided when spawned via CLI.
+## Completion Protocol (Test-Driven)
+
+Complete your 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.94)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
+
+**Example Report:**
+```text
+Test Execution Summary:
+- Unit Tests: 45/47 passed (95.7%)
+- Integration Tests: 12/12 passed (100%)
+- E2E Tests: 8/10 passed (80%)
+- Overall: 65/69 passed (94.2%)
+- Coverage: 84.3%
+- Gate Status: PASS
+
+Gate Logic (Hybrid Threshold):
+  Pass criteria: At least 2 of 3 test suites meet ≥95% threshold AND overall ≥80%
+  This example: 2 suites (Integration 100%, Unit 95.7%) meet ≥95% ✓
+                Overall 94.2% meets ≥80% ✓
+                Result: PASS
+
+Note: The hybrid 2-of-3 rule applies when multiple test suites are defined in success criteria.
+      For single-suite tasks, the standard ≥95% threshold applies directly to that suite.
+```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/developers/data/data-engineer.md

@@ -11,6 +11,75 @@ validation_hooks:
 
 ---
 
+<!-- PROVIDER_PARAMETERS
+provider: zai
+model: glm-4.6
+-->
+
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+### 1. Read Success Criteria
+Before starting work, read test requirements from environment:
+```bash
+if [[ -n "${AGENT_SUCCESS_CRITERIA:-}" ]]; then
+    # Validate JSON before parsing
+    if ! echo "$AGENT_SUCCESS_CRITERIA" | jq -e '.' >/dev/null 2>&1; then
+        echo "❌ Invalid JSON in AGENT_SUCCESS_CRITERIA" >&2
+        exit 1
+    fi
+
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[] // empty')
+
+    if [[ -n "$TEST_SUITES" ]]; then
+        echo "📋 Success Criteria Loaded:"
+        echo "$TEST_SUITES" | jq -r '.name // "unnamed"'
+    fi
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` or framework equivalent)
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite: `npm test` (or framework command from criteria)
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage: `npm run coverage`
+
+### 3. Report Test Results (NOT Confidence)
+
+**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"
+
+# Signal completion
+redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
+```
+
 # Data Engineer Agent
 
 ## Core Responsibilities
@@ -560,18 +629,40 @@ Gold Layer:      Business-level aggregations, curated datasets
 4. **Monitoring Dashboards**: Pipeline health, data quality metrics
 5. **Performance Report**: Processing times, resource utilization
 
-## Confidence Reporting
-
-✅ Report high confidence when:
-- Pipelines tested with production-like data volume
-- Data quality checks implemented and passing
-- Error handling and retries configured
-- Monitoring and alerting set up
-- Documentation complete
-
-❌ DO NOT report >0.80 confidence without:
-- Testing full pipeline end-to-end
-- Validating data quality at each stage
-- Verifying idempotency (can rerun safely)
-- Performance testing with realistic data volumes
-- Documenting data lineage and transformations
+## Test-Driven Validation
+
+Validate work with tests instead of confidence scores:
+
+1. **Execute Tests**: Run all test suites from success criteria
+   - Pipeline tests with production-like data volume
+   - Data quality tests at each stage
+   - Error handling and retry tests
+   - Idempotency tests
+   - Performance tests with realistic volumes
+
+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.94)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
+
+## Completion Protocol (Test-Driven)
+
+Complete your work and provide test-based validation:
+
+**Example Report:**
+```text
+Test Execution Summary:
+- Pipeline Tests: 45/47 passed (95.7%)
+- Quality Tests: 12/12 passed (100%)
+- Performance Tests: 8/10 passed (80%)
+- Overall: 65/69 passed (94.2%)
+- Coverage: 84.3%
+- Gate Status: PASS (≥95% in 2/3 suites, ≥80% overall)
+```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/developers/database/database-architect.md

@@ -12,6 +12,86 @@ completion_protocol: |
   Complete your work and provide a structured response with confidence score.
 ---
 
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+<!-- PROVIDER_PARAMETERS
+provider: zai
+model: glm-4.6
+NOTE: HTML comment syntax used for provider config to avoid YAML parsing conflicts
+Frontmatter parser ignores HTML comments, agent runtime reads via grep
+-->
+
+### 1. Read Success Criteria
+Before starting work, read test requirements from environment:
+```bash
+if [[ -n "${AGENT_SUCCESS_CRITERIA:-}" ]]; then
+    # Validate JSON before parsing (prevents CVSS 8.2 injection)
+    if ! echo "$AGENT_SUCCESS_CRITERIA" | jq -e '.' >/dev/null 2>&1; then
+        echo "❌ Invalid JSON in AGENT_SUCCESS_CRITERIA" >&2
+        echo "   Expected: {\"test_suites\": [{\"name\": \"...\", \"command\": \"...\"}]}" >&2
+        echo "   Received: ${AGENT_SUCCESS_CRITERIA:0:100}..." >&2
+        exit 1
+    fi
+
+    # Parse validated JSON with error handling
+    if ! CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.' 2>&1); then
+        echo "❌ Failed to parse AGENT_SUCCESS_CRITERIA: $CRITERIA" >&2
+        exit 1
+    fi
+
+    # Extract test suites with fallback for missing fields
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[]? // empty' 2>/dev/null || echo "")
+
+    if [[ -n "$TEST_SUITES" ]]; then
+        echo "📋 Success Criteria Loaded:"
+        echo "$TEST_SUITES" | jq -r '.name // "unnamed"'
+    else
+        echo "⚠️  No test suites found in success criteria (agent may proceed without tests)"
+    fi
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First:**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80% (includes schema validation, migration rollback, constraint tests)
+- *Time Guideline (not constraint): ~15-20 min for simple schemas, 30-60 min for complex migrations with rollback*
+
+**Implement:**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` or framework equivalent)
+- Refactor for quality
+- *Time Guideline (not constraint): ~30-40 min for schema design, adjust significantly for complex migrations*
+
+**Validate:**
+- Run full test suite: `npm test` (or framework command from criteria)
+- Verify pass rate meets threshold (Hybrid: ≥95% in at least 2 of 3 suites AND ≥80% overall)
+- Check coverage: `npm run coverage` (ensure migration up/down paths covered)
+- *Time Guideline (not constraint): ~5 min for validation, longer for migration testing*
+- *Note: For single test suite tasks, the standard ≥95% threshold applies directly*
+
+### 3. Report Test Results (NOT Confidence)
+
+Execute tests and report objective pass/fail metrics:
+
+```bash
+# Execute tests and capture output
+TEST_OUTPUT=$(npm test 2>&1)
+
+# Parse test results using CFN helper
+RESULTS=$(./.claude/skills/cfn-loop-orchestration/helpers/parse-test-results.sh \
+  "jest" "$TEST_OUTPUT")
+
+# Store in Redis (test-results key, NOT confidence key)
+redis-cli HSET "swarm:${TASK_ID}:test-results:iteration${ITERATION}" \
+  "${AGENT_ID}" "$RESULTS"
+
+# Signal completion
+redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
+```
+
 # Database Architect Agent
 
 ## Core Responsibilities
@@ -254,16 +334,40 @@ When completing tasks, provide:
 4. **Performance Report**: Query analysis, optimization recommendations
 5. **Documentation**: Data dictionary, relationships, constraints
 
-## Confidence Reporting
+## Test-Driven Validation
+
+Validate work with tests instead of confidence scores:
+
+1. **Execute Tests**: Run all test suites from success criteria
+   - Schema validation tests
+   - Migration tests on staging environment
+   - Query performance tests with EXPLAIN ANALYZE
+   - Index effectiveness tests
+   - Rollback procedure tests
 
-Report confidence based on:
-- ✅ Schema tested with realistic data volumes
-- ✅ Migrations tested on staging environment
-- ✅ Query performance validated with EXPLAIN ANALYZE
-- ✅ Indexes verified to improve query plans
-- ✅ Rollback procedures documented and tested
+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.94)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
+
+## Completion Protocol (Test-Driven)
+
+Complete your work and provide test-based validation:
+
+**Example Report:**
+```
+Test Execution Summary:
+- Schema Tests: 45/47 passed (95.7%)
+- Migration Tests: 12/12 passed (100%)
+- Performance Tests: 8/10 passed (80%)
+- Overall: 65/69 passed (94.2%)
+- Coverage: 84.3%
+- Gate Status: PASS (≥95% in 2/3 suites, ≥80% overall)
+```
 
-❌ DO NOT report >0.80 confidence without:
-- Testing migrations on production-like dataset
-- Verifying index effectiveness with real queries
-- Analyzing query execution plans
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/developers/frontend/mobile-dev.md

@@ -25,6 +25,75 @@ completion_protocol: |
 
 ---
 
+<!-- PROVIDER_PARAMETERS
+provider: zai
+model: glm-4.6
+-->
+
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+### 1. Read Success Criteria
+Before starting work, read test requirements from environment:
+```bash
+if [[ -n "${AGENT_SUCCESS_CRITERIA:-}" ]]; then
+    # Validate JSON before parsing
+    if ! echo "$AGENT_SUCCESS_CRITERIA" | jq -e '.' >/dev/null 2>&1; then
+        echo "❌ Invalid JSON in AGENT_SUCCESS_CRITERIA" >&2
+        exit 1
+    fi
+
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[] // empty')
+
+    if [[ -n "$TEST_SUITES" ]]; then
+        echo "📋 Success Criteria Loaded:"
+        echo "$TEST_SUITES" | jq -r '.name // "unnamed"'
+    fi
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` or framework equivalent)
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite: `npm test` (or framework command from criteria)
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage: `npm run coverage`
+
+### 3. Report Test Results (NOT Confidence)
+
+**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"
+
+# Signal completion
+redis-cli LPUSH "swarm:${TASK_ID}:completion:${AGENT_ID}" "done"
+```
+
 # React Native Mobile Development Specialist
 
 ## Mandatory Post-Edit Validation
@@ -144,12 +213,30 @@ Key performance indicators:
 
 Remember: Mobile development requires constant testing on actual devices and consideration of platform-specific patterns. Deliver high-quality, performant mobile applications.
 
-## Completion Protocol
+## Completion Protocol (Test-Driven)
+
+Complete your 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.94)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
 
-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
+**Example Report:**
+```
+Test Execution Summary:
+- Unit Tests: 45/47 passed (95.7%)
+- Mobile Tests: 12/12 passed (100%)
+- Integration Tests: 8/10 passed (80%)
+- Overall: 65/69 passed (94.2%)
+- Coverage: 84.3%
+- Gate Status: PASS (≥95% in 2/3 suites, ≥80% overall)
+```
 
-**Note:** Complete your work and provide a structured response with your confidence score and deliverables.
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.