claude-flow-novice 2.15.8 → 2.15.10

package/.claude/skills/cfn-redis-coordination/report-completion.sh

@@ -2,7 +2,10 @@
 # Report agent completion and confidence to Redis
 # Replaces deprecated invoke-waiting-mode.sh for CFN Loop coordination
 #
-# Usage: report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>]
+# Usage:
+#   report-completion.sh --task-id <id> --agent-id <id> --confidence <0.0-1.0>
+#                        [--iteration <n>] [--namespace <ns>] [--result <json>]
+#                        [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]
 
 set -euo pipefail
 
@@ -16,6 +19,10 @@ AGENT_ID=""
 CONFIDENCE=""
 RESULT=""
 ITERATION="1"
+NAMESPACE="swarm"
+TEST_PASS_RATE=""
+TESTS_RUN=""
+TESTS_PASSED=""
 
 while [[ $# -gt 0 ]]; do
     case $1 in
@@ -39,6 +46,22 @@ while [[ $# -gt 0 ]]; do
             ITERATION="$2"
             shift 2
             ;;
+        --namespace)
+            NAMESPACE="$2"
+            shift 2
+            ;;
+        --test-pass-rate)
+            TEST_PASS_RATE="$2"
+            shift 2
+            ;;
+        --tests-run)
+            TESTS_RUN="$2"
+            shift 2
+            ;;
+        --tests-passed)
+            TESTS_PASSED="$2"
+            shift 2
+            ;;
         *)
             echo "Unknown option: $1" >&2
             exit 1
@@ -51,7 +74,9 @@ done
 # Wrapper provides graceful Task mode fallback when Redis unavailable
 if [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONFIDENCE" ]; then
     echo "Error: Missing required parameters" >&2
-    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0> [--result <json>] [--iteration <n>]" >&2
+    echo "Usage: $0 --task-id <id> --agent-id <id> --confidence <0.0-1.0>" >&2
+    echo "       [--iteration <n>] [--namespace <ns>] [--result <json>]" >&2
+    echo "       [--test-pass-rate <pct>] [--tests-run <n>] [--tests-passed <n>]" >&2
     exit 1
 fi
 
@@ -66,24 +91,44 @@ fi
 # Measured improvement: ~62% coordination overhead reduction in standard mode
 {
     echo "MULTI"
-    echo "LPUSH swarm:${TASK_ID}:${AGENT_ID}:done complete"
-    echo "SET swarm:${TASK_ID}:${AGENT_ID}:confidence $CONFIDENCE EX 3600"
+    echo "LPUSH ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done complete"
+    echo "SET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:confidence $CONFIDENCE EX 3600"
+
+    # Build result hash with test metrics if provided
+    RESULT_HASH_ARGS="confidence $CONFIDENCE iteration $ITERATION"
 
     if [ -n "$RESULT" ]; then
-        echo "HSET swarm:${TASK_ID}:${AGENT_ID}:result confidence $CONFIDENCE iteration $ITERATION result $RESULT timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
-    else
-        echo "HSET swarm:${TASK_ID}:${AGENT_ID}:result confidence $CONFIDENCE iteration $ITERATION timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS result $RESULT"
     fi
 
+    if [ -n "$TEST_PASS_RATE" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS test_pass_rate $TEST_PASS_RATE"
+    fi
+
+    if [ -n "$TESTS_RUN" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_run $TESTS_RUN"
+    fi
+
+    if [ -n "$TESTS_PASSED" ]; then
+        RESULT_HASH_ARGS="$RESULT_HASH_ARGS tests_passed $TESTS_PASSED"
+    fi
+
+    RESULT_HASH_ARGS="$RESULT_HASH_ARGS timestamp $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+    echo "HSET ${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result $RESULT_HASH_ARGS"
+
     echo "EXEC"
 } | redis-cli > /dev/null
 
 # Step 4: Add to agent completion list (for orchestrator tracking)
-redis-cli LPUSH "swarm:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
+redis-cli LPUSH "${NAMESPACE}:${TASK_ID}:completed_agents" "$AGENT_ID" > /dev/null
 
 # Step 5: Set TTL on keys (auto-cleanup)
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
-redis-cli EXPIRE "swarm:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
+redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:result" 3600 > /dev/null
+redis-cli EXPIRE "${NAMESPACE}:${TASK_ID}:${AGENT_ID}:done" 3600 > /dev/null
 
 echo "✅ Reported completion for agent: $AGENT_ID (confidence: $CONFIDENCE)"
+if [ -n "$TEST_PASS_RATE" ]; then
+    echo "   Test pass rate: $TEST_PASS_RATE%"
+fi
 exit 0

package/.claude/skills/cfn-redis-coordination/store-context.sh

@@ -4,6 +4,7 @@
 #
 # Usage:
 #   store-context.sh --task-id <id> --key <key> --value <value> [--namespace <ns>]
+#   store-context.sh --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]
 #   store-context.sh <task_id> <context_json> (legacy mode)
 
 set -euo pipefail
@@ -18,6 +19,8 @@ KEY=""
 VALUE=""
 NAMESPACE="swarm"
 CONTEXT=""
+EPIC=""
+MODE=""
 
 # Parse arguments
 while [[ $# -gt 0 ]]; do
@@ -38,6 +41,14 @@ while [[ $# -gt 0 ]]; do
       NAMESPACE="$2"
       shift 2
       ;;
+    --epic)
+      EPIC="$2"
+      shift 2
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
     *)
       # Legacy mode: positional arguments
       if [ -z "$TASK_ID" ]; then
@@ -54,10 +65,29 @@ done
 if [ -z "$TASK_ID" ]; then
     echo "Error: --task-id or TASK_ID required" >&2
     echo "Usage: $0 --task-id <id> --key <key> --value <value> [--namespace <ns>]" >&2
+    echo "   or: $0 --task-id <id> --epic <epic> --mode <mode> [--namespace <ns>]" >&2
     echo "   or: $0 <task_id> <context_json> (legacy)" >&2
     exit 1
 fi
 
+# Handle epic+mode mode (new)
+if [ -n "$EPIC" ] && [ -n "$MODE" ]; then
+  # Store epic and mode with task context
+  REDIS_KEY="${NAMESPACE}:${TASK_ID}:context"
+
+  redis-cli HSET "$REDIS_KEY" \
+      "epic" "$EPIC" \
+      "mode" "$MODE" \
+      "updated_at" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+      > /dev/null
+
+  # Set TTL (24 hours)
+  redis-cli EXPIRE "$REDIS_KEY" 86400 > /dev/null
+
+  echo "✅ Context stored: epic=$EPIC, mode=$MODE for task: $TASK_ID"
+  exit 0
+fi
+
 # Handle structured mode (new)
 if [ -n "$KEY" ] && [ -n "$VALUE" ]; then
   # Store structured context with specific key
@@ -89,5 +119,5 @@ if [ -n "$CONTEXT" ]; then
   exit 0
 fi
 
-echo "Error: Either --key/--value or <context_json> required" >&2
+echo "Error: Either --epic/--mode, --key/--value, or <context_json> required" >&2
 exit 1

package/README.md

@@ -4,7 +4,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
 [![CI Pipeline](https://github.com/yourusername/claude-flow-novice/actions/workflows/ci.yml/badge.svg)](https://github.com/yourusername/claude-flow-novice/actions/workflows/ci.yml)
-[![Coverage Report](https://img.shields.io/badge/coverage-dynamic-blue)](docs/CI_CD_PIPELINE.md)
+[![Coverage Report](https://img.shields.io/badge/coverage-dynamic-blue)](.github/workflows)
 
 Autonomous self-correcting AI agent orchestration with multi-domain support and intelligent learning capabilities.
 
@@ -437,25 +437,220 @@ See `readme/logs-tools.md` for complete documentation.
 
 ## Testing
 
+Claude Flow Novice includes comprehensive test suites across multiple execution modes and test types. Choose the appropriate test runner based on your development context.
+
+### Quick Start
+
+```bash
+# Run all npm-based tests (unit, integration, e2e)
+npm test
+
+# Run CLI mode test suite (test-driven validation)
+./tests/cli-mode/run-all-tests.sh
+
+# Run Docker mode test suite (45 production tests)
+./tests/docker-mode/run-all-implementations.sh
+```
+
+### Test Execution Modes
+
+#### CLI Mode Tests (Production)
+Run the CLI mode test suite to validate end-to-end coordination, quality gates, and agent spawning:
+
+```bash
+# Full test suite with all assertions
+./tests/cli-mode/run-all-tests.sh
+
+# Expected runtime: ~5-10 minutes
+# Tests: 8 suites, 159 total assertions
+# Coverage: Redis coordination, threshold enforcement, agent spawning, path resolution
+```
+
+**Validates:**
+- `/cfn-loop-cli` slash command workflow
+- Coordinator spawning and orchestration
+- Loop 3 → Loop 2 → Product Owner progression
+- Quality gate enforcement (MVP/Standard/Enterprise modes)
+- Redis coordination layer
+- Agent tool access and permissions
+
+**Prerequisites:**
+- Redis running (`redis-server`)
+- Project built (`npm run build`)
+- Z.ai API key configured (`.env`) for integration tests
+
+**Documentation:** See `tests/cli-mode/README.md` for detailed test descriptions and results.
+
+#### Docker Mode Tests (Integration)
+Run the Docker mode test suite to validate real container-based orchestration:
+
+```bash
+# Run all 45 Docker test implementations
+./tests/docker-mode/run-all-implementations.sh
+
+# Expected runtime: ~3-5 minutes
+# Tests: 45 production tests across 3 suites
+# Coverage: Coordinator spawning, orchestrator workflow, TDD compliance
+```
+
+**Test Suites:**
+- Coordinator Spawning (13 tests): Container cleanup, exit codes, service discovery
+- Orchestrator Workflow (13 tests): Iteration management, monitoring, recovery
+- TDD Compliance (19 tests): Test-driven validation, metrics collection, parallel execution
+
+**Prerequisites:**
+- Docker daemon running (`docker ps`)
+- No port conflicts (Docker networks auto-created)
+- ~2GB available memory for container execution
+
+**Documentation:** See `tests/docker-mode/README.md` for test categories and patterns.
+
+#### NPM-Based Tests (Development)
+Run standard npm test commands for fast feedback during development:
+
 ```bash
 # Run all tests
 npm test
 
 # Run specific test suites
-npm run test:unit
-npm run test:integration
-npm run test:e2e
+npm run test:unit           # Unit tests only
+npm run test:integration    # Integration tests only
+npm run test:e2e           # End-to-end tests only
 
-# CFN Loop end-to-end tests
-./tests/cfn-v3/test-e2e-cfn-loop.sh
+# Run with coverage
+npm test -- --coverage
+
+# Watch mode (re-run on file changes)
+npm test -- --watch
+```
+
+**Expected runtime:**
+- Unit tests: ~1-2 minutes
+- Integration tests: ~2-3 minutes
+- E2E tests: ~3-5 minutes
+
+#### CFN Loop End-to-End Tests
+Run specialized CFN Loop tests for validation and debugging:
+
+```bash
+# Validate CFN Loop coordinator handoffs
 ./tests/cfn-v3/test-coordinator-handoffs.sh
+
+# Full CFN Loop e2e test
+./tests/cfn-v3/test-e2e-cfn-loop.sh
+
+# Enterprise change management tests
+./tests/enterprise/run-all-enterprise-tests.sh
 ```
 
----
+### Test Organization
+
+```
+tests/
+├── cli-mode/                          # CLI mode validation (8 tests, 159 assertions)
+│   ├── README.md                      # CLI test documentation
+│   ├── run-all-tests.sh              # Test runner
+│   └── test-*.sh                     # Individual test suites
+├── docker-mode/                       # Docker integration tests (45 tests)
+│   ├── README.md                      # Docker test documentation
+│   ├── run-all-implementations.sh     # Test runner
+│   └── implementations/
+│       ├── coordinator-spawning-real-tests.sh
+│       ├── orchestrator-workflow-real-tests.sh
+│       └── tdd-compliance-real-tests.sh
+├── docker/                            # Docker-based core tests
+│   ├── coordination/                  # Redis coordination tests
+│   ├── lifecycle/                     # Container lifecycle tests
+│   └── perf/                          # Performance benchmarks
+├── cfn-v3/                           # CFN Loop validation tests
+├── enterprise/                        # Enterprise mode tests
+├── CLAUDE.md                          # Test authoring standards
+├── test-utils.sh                      # Shared test utilities
+└── README.md                          # Test suite documentation
+```
+
+### Test Coverage Matrix
+
+| Mode | Type | Tests | Duration | Prerequisites |
+|------|------|-------|----------|---|
+| CLI | Unit + Integration + E2E | 159 assertions | 5-10 min | Redis, npm build |
+| Docker | Production integration | 45 tests | 3-5 min | Docker daemon |
+| NPM | Development | Variable | 1-5 min | Node.js, npm |
+| CFN Loop | Workflow validation | Variable | 5-15 min | Full environment |
+
+### Test Authoring Guidelines
+
+For developers writing new tests, see `tests/CLAUDE.md` which documents:
+- Boilerplate template structure
+- GIVEN/WHEN/THEN assertion patterns
+- Production testing requirements (BUG #21)
+- Infrastructure vs integration test patterns
+- Cleanup and resource management
+- Review checklist for test quality
+
+Key principles:
+- Infrastructure tests (mocks OK): Docker networking, volumes, Redis connectivity
+- Integration tests (real images/scripts): Agent spawning, CLI execution, production workflows
+- Always use `set -euo pipefail` and `trap cleanup EXIT`
+- Route output through `log_step`, `log_info`, `annotate`, `assert_success` helpers
+- Cite relevant bugs in test comments for future context
+
+### CI/CD Integration
+
+Tests run automatically in GitHub Actions on every push and pull request. See [CI/CD Pipeline Documentation](.github/workflows) for:
+- Coverage gates (80%+ lines/statements/functions)
+- Test failure notifications
+- Performance benchmarking
+- Security scanning
+- Deployment workflows
+
+### Troubleshooting
+
+**Redis not available:**
+```bash
+# Start Redis in background
+redis-server --daemonize yes
+
+# Or run in Docker
+docker run -d -p 6379:6379 redis:7-alpine
+```
+
+**Docker permission denied:**
+```bash
+# Add user to docker group
+sudo usermod -aG docker $USER
+newgrp docker
+```
+
+**Port conflicts:**
+```bash
+# Stop and remove existing containers
+docker stop $(docker ps -aq)
+docker rm $(docker ps -aq)
+
+# Clean up Docker networks
+docker network prune -f
+```
+
+**Test failures with unclear messages:**
+```bash
+# Run with verbose output
+DEBUG=true ./tests/cli-mode/run-all-tests.sh
+DEBUG=true ./tests/docker-mode/run-all-implementations.sh
+
+# Check test logs in .artifacts/
+tail -100 .artifacts/logs/test-execution.log
+```
 
-## Contributing
+### Related Documentation
 
-We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+- **Test Suite Overview:** `tests/README.md`
+- **Test Authoring Standards:** `tests/CLAUDE.md`
+- **CLI Mode Details:** `tests/cli-mode/README.md`
+- **Docker Mode Details:** `tests/docker-mode/README.md`
+- **Test Coverage Analysis:** `tests/TEST_COVERAGE_MATRIX.md`
+- **CFN Loop Architecture:** `docs/CFN_LOOP_ARCHITECTURE.md`
+- **CI/CD Pipeline:** `.github/workflows`
 
 ### Development Setup
 
@@ -476,7 +671,7 @@ npm run build
 
 ### CI/CD Pipeline
 
-Comprehensive GitHub Actions automation with unit testing, integration testing, coverage gates (80%+ lines/statements/functions), security scanning, and deployment workflows. See [CI/CD Pipeline Documentation](docs/CI_CD_PIPELINE.md) for details.
+Comprehensive GitHub Actions automation with unit testing, integration testing, coverage gates (80%+ lines/statements/functions), security scanning, and deployment workflows. See [CI/CD Pipeline Documentation](.github/workflows) for details.
 
 ---
 

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

@@ -845,6 +845,8 @@ fi
 Complete your frontend coordination work and provide test-based validation:
 
 1. **Execute Tests**: Run all test suites from success criteria
+
+```bash
 # Parse natively (no external dependencies)
 PASS=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= passing)' || echo "0")
 FAIL=$(echo "$TEST_OUTPUT" | grep -oP '\d+(?= failing)' || echo "0")
@@ -853,7 +855,10 @@ RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0
 
 # Return results (Main Chat receives automatically in Task Mode)
 echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
-   - Coverage: ≥80%
+```
+
+2. **Review Metrics**: Verify test pass rate ≥95%
+3. **Coverage Check**: Ensure test coverage ≥80%
 4. **Store in Redis**: Use test-results key (not confidence key)
 5. **Signal Completion**: Push to completion queue