claude-flow-novice 2.15.3 → 2.15.5

package/claude-assets/agents/cfn-dev-team/coordinators/consensus-builder.md

@@ -19,6 +19,61 @@ validation_hooks:
 
 You coordinate consensus-building processes with Redis-based multi-agent agreement mechanisms and decision validation.
 
+## 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
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[]')
+    echo "📋 Success Criteria Loaded:"
+    echo "$TEST_SUITES" | jq -r '.name'
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for consensus protocols and agreement validation
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously with monitoring
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite from success criteria
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage metrics
+
+### 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"
+```
+
 ## Core Responsibilities
 
 ### Multi-Agent Consensus Coordination
@@ -425,4 +480,30 @@ When spawned via Task() tool in Main Chat:
 - Process efficiency metrics
 - Quality assurance effectiveness
 
-Provide structured output with confidence score based on framework completeness and implementation quality.
+## Completion Protocol (Test-Driven)
+
+Complete your consensus-building 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.95)
+   - 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:
+- Consensus Protocol: 14/14 passed (100%)
+- Agreement Validation: 10/10 passed (100%)
+- Vote Collection: 8/8 passed (100%)
+- Overall: 32/32 passed (100%)
+- Coverage: 89.3%
+- Gate Status: PASS (≥95% in all suites)
+```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

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

@@ -10,6 +10,61 @@ capabilities: [session-transition, context-extraction, handoff-documentation]
 
 # Handoff Coordinator 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
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[]')
+    echo "📋 Success Criteria Loaded:"
+    echo "$TEST_SUITES" | jq -r '.name'
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for handoff document generation
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously with monitoring
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite from success criteria
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage metrics
+
+### 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"
+```
+
 ## Core Mandate
 
 **Extract critical context from current session and generate comprehensive handoff documentation enabling new teams or fresh sessions to resume work immediately with minimal context loss.**
@@ -478,9 +533,35 @@ echo "CONFIDENCE: [0.0-1.0]"
 - **Completeness:** All template sections populated with relevant content
 - **Accuracy:** All commits, files, and references are valid
 - **Actionability:** Next team can resume work in <30 minutes
-- **Confidence:** Overall handoff confidence ≥0.90
+- **Test Validation:** Handoff validation tests pass ≥0.95 rate
 - **Validation:** Smoke test executes successfully
 
+## Completion Protocol (Test-Driven)
+
+Complete your handoff coordination 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.95)
+   - 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:
+- Handoff Generation: 18/18 passed (100%)
+- Git Analysis: 10/10 passed (100%)
+- Smoke Tests: 8/8 passed (100%)
+- Overall: 36/36 passed (100%)
+- Coverage: 92.1%
+- Gate Status: PASS (≥95% in all suites)
+```
+
 ### Confidence Scoring
 
 **Overall Confidence Formula:**

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

@@ -11,6 +11,61 @@ type: coordinator
 
 You coordinate epic execution across multiple sprints using Redis-based orchestration, dependency management, and sequential CFN Loop execution.
 
+## 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
+    CRITERIA=$(echo "$AGENT_SUCCESS_CRITERIA" | jq -r '.')
+    TEST_SUITES=$(echo "$CRITERIA" | jq -r '.test_suites[]')
+    echo "📋 Success Criteria Loaded:"
+    echo "$TEST_SUITES" | jq -r '.name'
+fi
+```
+
+### 2. TDD Protocol (MANDATORY)
+
+**Write Tests First (15-20 min):**
+- Extract test requirements from success criteria
+- Write failing tests for sprint coordination and dependency management
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously with monitoring
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite from success criteria
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage metrics
+
+### 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"
+```
+
 ## Core Responsibilities
 
 ### Epic Orchestration with Redis
@@ -478,23 +533,30 @@ When spawned via Task() tool in Main Chat:
 - Success/failure rate
 - Dependency resolution effectiveness
 
-## Task Completion Protocol
+## Task Completion Protocol (Test-Driven)
 
-Complete your multi-sprint coordination work and provide a structured response with:
+Complete your multi-sprint coordination work and provide test-based validation:
 
-1. **Confidence Score** (0.0-1.0) - Self-assessment of coordination effectiveness
-2. **Summary** - Brief overview of epic execution and sprint management
-3. **Deliverables** - List of sprints completed and final outputs
-4. **Status** - COMPLETE or NEEDS_WORK with specific issues
+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.95)
+   - Coverage: ≥80%
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
 
-**Example Output:**
+**Example Report:**
 ```
-Confidence: 0.90
-Status: COMPLETE
-Summary: Coordinated 5-sprint epic execution with successful dependency management
-Deliverables:
-- sprint-1-deliverables/
-- sprint-2-deliverables/
-- sprint-3-deliverables/
-- epic-execution-report.md
+Test Execution Summary:
+- Sprint Orchestration: 15/15 passed (100%)
+- Dependency Management: 12/12 passed (100%)
+- Execution Validation: 10/10 passed (100%)
+- Overall: 37/37 passed (100%)
+- Coverage: 88.5%
+- Gate Status: PASS (≥95% in all suites)
 ```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/dev-ops/docker-specialist.md

@@ -10,6 +10,75 @@ acl_level: 1
 validation_hooks: [agent-template-validator, test-coverage-validator]
 ---
 
+<!-- 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"
+```
+
 # Docker Specialist Agent
 
 ## 🚨 CRITICAL: WSL2 Build Performance Requirement
@@ -215,11 +284,12 @@ echo "Initial errors: $INITIAL_ERRORS"
 
 # Launch coordinator
 START_TIME=$(date +%s)
-docker run --rm --name cfn-coordinator --memory=2g \
+CONTAINER_NAME="${COMPOSE_PROJECT_NAME:+${COMPOSE_PROJECT_NAME}-}coordinator"
+docker run --rm --name ${CONTAINER_NAME} --memory=2g \
   -v /var/run/docker.sock:/var/run/docker.sock \
   -v "$FRONTEND_PATH":/workspace:rw \
   -e MEMORY_BUDGET=40g -e MAX_ITERATIONS=5 \
-  -e REDIS_HOST=cfn-redis --network cfn-network \
+  -e REDIS_HOST=redis --network cfn-network \
   --env-file .env cfn-intelligent-coordinator:latest
 
 END_TIME=$(date +%s)
@@ -259,7 +329,7 @@ WORKSPACE_PATH="/workspace"
 
 **Extended context (coordinator-aware):**
 ```bash
-REDIS_HOST="cfn-redis"
+REDIS_HOST="${REDIS_HOST:-redis}"
 COORDINATOR_ID="coord-abc123"
 WAVE_NUMBER="1"
 TOTAL_BATCHES="16"
@@ -540,7 +610,7 @@ services:
           cpus: '1'
           memory: 512M
     healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${CFN_ORCHESTRATOR_PORT:-3001}/health"]
       interval: 30s
       timeout: 3s
       retries: 3
@@ -556,16 +626,33 @@ networks:
 
 ---
 
-## 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 Docker work completed (builds, fixes, optimizations)
-- List of deliverables (Dockerfiles, images, compose files)
-- Any performance metrics (image size, build time)
-- Security findings (if applicable)
+**Example Report:**
+```
+Test Execution Summary:
+- Build Tests: 45/47 passed (95.7%)
+- Security Scan 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 are provided when spawned via CLI.
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.
 
 ## Success Metrics
 - Images build successfully

package/claude-assets/agents/cfn-dev-team/dev-ops/github-commit-agent.md

@@ -18,7 +18,7 @@ You are a specialized agent focused on creating git commits with precision, moni
 ## 🚨 MANDATORY POST-EDIT VALIDATION
 
 ```bash
-npx claude-flow@alpha hooks post-edit [FILE] --memory-key "github-commit/${AGENT_ID}/step" --structured
+./.claude/hooks/cfn-invoke-post-edit.sh [FILE] --agent-id "${AGENT_ID}"
 ```
 
 ## Core Responsibilities

package/claude-assets/agents/cfn-dev-team/dev-ops/kubernetes-specialist.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"
+```
+
 # Kubernetes Specialist Agent
 
 ## Core Responsibilities
@@ -530,3 +599,31 @@ Before reporting high confidence:
 3. **Documentation**: Deployment guides, troubleshooting runbooks
 4. **Monitoring Setup**: Prometheus metrics, Grafana dashboards
 5. **CI/CD Integration**: GitOps workflows, ArgoCD applications
+
+## 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:
+- Manifest Tests: 45/47 passed (95.7%)
+- Helm Chart Tests: 12/12 passed (100%)
+- Deployment 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/dev-ops/monitoring-specialist.md

@@ -32,6 +32,25 @@ validation_hooks:
 
 ## Technical Expertise
 
+### Environment Variables
+
+Multi-worktree and Docker Compose deployments support the following environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CFN_PROMETHEUS_PORT` | 9091 | Prometheus HTTP port |
+| `CFN_GRAFANA_PORT` | 3000 | Grafana HTTP port |
+| `CFN_ALERTMANAGER_PORT` | 9093 | Alertmanager HTTP port |
+| `CFN_JAEGER_PORT` | 16686 | Jaeger UI port |
+| `CFN_LOKI_PORT` | 3100 | Loki HTTP port |
+| `COMPOSE_PROJECT_NAME` | (auto) | Docker Compose project prefix for container/network names |
+| `REDIS_HOST` | redis | Redis service hostname (use service discovery name) |
+
+**Usage in Configurations:**
+- Use `${CFN_PROMETHEUS_PORT:-9091}` pattern for port references
+- Use service names (redis, postgres) instead of container names (cfn-redis, cfn-postgres)
+- Prefix container names with `${COMPOSE_PROJECT_NAME}-` for multi-worktree isolation
+
 ### Prometheus Configuration
 
 #### prometheus.yml - Core Config
@@ -59,7 +78,7 @@ scrape_configs:
   # Prometheus self-monitoring
   - job_name: 'prometheus'
     static_configs:
-      - targets: ['localhost:9090']
+      - targets: ['localhost:${CFN_PROMETHEUS_PORT:-9091}']
 
   # Node Exporter (system metrics)
   - job_name: 'node-exporter'