claude-flow-novice 2.15.2 → 2.15.4

package/claude-assets/agents/cfn-dev-team/README.md

@@ -92,6 +92,109 @@ Each agent MUST include:
    - Redis coordination
 7. **ACL Level**: Access control level (1-5)
 
+## Multi-Worktree Coordination
+
+### Environment Variables Provided by Coordinator
+
+When coordinators spawn agents in multi-worktree environments, the following environment variables are automatically injected:
+
+```bash
+COMPOSE_PROJECT_NAME="cfn-feature-auth"           # Unique project name per branch
+CFN_REDIS_PORT=6421                               # Redis port (6379 + offset)
+CFN_POSTGRES_PORT=5474                            # Postgres port (5432 + offset)
+WORKTREE_BRANCH="feature-auth"                    # Git branch name
+```
+
+### Service Discovery Pattern
+
+Agents use Docker service names for internal communication:
+
+```bash
+# Redis connection (within Docker network)
+redis-cli -h redis -p 6379
+
+# PostgreSQL connection (within Docker network)
+PGHOST=postgres PGPORT=5432 psql -U postgres
+
+# HTTP connections
+curl http://orchestrator:3001/health
+```
+
+**Important**: Service names are resolved by Docker's internal DNS within the network. Container names (e.g., `cfn-redis-1`) will NOT resolve.
+
+### Multi-Worktree Examples
+
+#### Scenario 1: Feature Development (Feature-Auth Branch)
+
+```bash
+# Branch: feature-auth
+# Offset: ~42 (calculated from branch name)
+# Ports: Redis=6421, Postgres=5474, Orchestrator=3043
+
+# Coordinator injects:
+export COMPOSE_PROJECT_NAME="cfn-feature-auth"
+export CFN_REDIS_PORT=6421
+export CFN_POSTGRES_PORT=5474
+
+# Agent connects to correct worktree services
+redis-cli -h redis -p 6421
+psql -h postgres -p 5474
+```
+
+#### Scenario 2: Bugfix Work (Bugfix-Validation Branch)
+
+```bash
+# Branch: bugfix-validation
+# Offset: ~78 (calculated from branch name)
+# Ports: Redis=6457, Postgres=5510, Orchestrator=3079
+
+# Coordinator injects:
+export COMPOSE_PROJECT_NAME="cfn-bugfix-validation"
+export CFN_REDIS_PORT=6457
+export CFN_POSTGRES_PORT=5510
+
+# Agent connects to correct worktree services
+redis-cli -h redis -p 6457
+psql -h postgres -p 5510
+```
+
+#### Scenario 3: Main Branch (Production Ready)
+
+```bash
+# Branch: main/master
+# Offset: 0 (main gets priority)
+# Ports: Redis=6379, Postgres=5432, Orchestrator=3001
+
+# Coordinator injects:
+export COMPOSE_PROJECT_NAME="cfn-main"
+export CFN_REDIS_PORT=6379
+export CFN_POSTGRES_PORT=5432
+
+# Standard ports - no offset
+redis-cli -h redis -p 6379
+psql -h postgres -p 5432
+```
+
+### Running Multiple Worktrees Simultaneously
+
+Team members can develop in parallel without conflicts:
+
+```bash
+# Developer 1: Feature branch
+worktree_1/feature-auth$ ./scripts/docker/run-in-worktree.sh up -d
+# Ports: Redis=6421, Postgres=5474
+
+# Developer 2: Bugfix branch (same machine)
+worktree_2/bugfix-validation$ ./scripts/docker/run-in-worktree.sh up -d
+# Ports: Redis=6457, Postgres=5510
+
+# Developer 3: Main branch
+worktree_3/main$ ./scripts/docker/run-in-worktree.sh up -d
+# Ports: Redis=6379, Postgres=5432
+
+# All three run simultaneously without port conflicts!
+```
+
 ## Adding New Agents
 
 ### Process

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

@@ -22,7 +22,7 @@ validation_hooks:
 ## 🚨 MANDATORY POST-EDIT VALIDATION
 
 ```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] --memory-key "goal-planner/plan" --structured
+./.claude/hooks/cfn-invoke-post-edit.sh [FILE_PATH] --agent-id "${AGENT_ID}"
 ```
 
 ## GOAP Planning Framework

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

@@ -12,6 +12,61 @@ mode_support: [cli]
 
 You coordinate frontend CFN Loops with visual iteration workflow, mockup integration, and brand guideline enforcement.
 
+## 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 frontend validation and visual checks
+- Ensure test coverage ≥80%
+
+**Implement (30-40 min):**
+- Write minimum code to pass tests
+- Run tests continuously (Playwright, visual regression tests)
+- Refactor for quality
+
+**Validate (5 min):**
+- Run full test suite from success 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 -- --reporter=json 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 Responsibility
 
 **CLI Mode Only**: Orchestrate visual-first frontend development with Redis-based coordination and dual validation (screenshot + video).
@@ -846,27 +901,34 @@ if ! command -v playwright &> /dev/null; then
 fi
 ```
 
-## Task Completion Protocol
+## Task Completion Protocol (Test-Driven)
 
-Complete your frontend coordination work and provide a structured response with:
+Complete your frontend coordination work and provide test-based validation:
 
-1. **Confidence Score** (0.0-1.0) - Self-assessment of coordination quality
-2. **Summary** - Brief overview of frontend implementation coordination
-3. **Deliverables** - List of components and files created
-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.92
-Status: COMPLETE
-Summary: Coordinated frontend implementation with visual validation workflow
-Deliverables:
-- src/components/LoginForm.tsx
-- tests/frontend/LoginForm.test.tsx
-- docs/LoginForm_IMPLEMENTATION.md
-- visual-validation-report.json
+Test Execution Summary:
+- Playwright Tests: 12/12 passed (100%)
+- Visual Tests: 8/10 passed (80%)
+- Integration Tests: 15/15 passed (100%)
+- Overall: 35/37 passed (94.6%)
+- Coverage: 85.2%
+- Gate Status: PASS (≥95% in 2/3 suites, ≥80% overall)
 ```
 
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.
+
 ## Related Documentation
 
 - Guide: `.claude/commands/cfn/CFN_LOOP_FRONTEND.md`

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

@@ -12,6 +12,316 @@ acl_level: 3
 
 You coordinate CFN Loop v3 execution with Redis-based agent orchestration and CLI spawning.
 
+## 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 coordination protocols
+- 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"
+```
+
+## Success Criteria Auto-Generation (Phase 3)
+
+### Overview
+
+When `--success-criteria` parameter is NOT provided, the coordinator MUST auto-generate appropriate success criteria based on task analysis.
+
+### Task Analysis Keywords
+
+**Security-Critical (100% pass rate):**
+- Keywords: `auth`, `authentication`, `authorization`, `security`, `crypto`, `encryption`, `token`, `JWT`, `OAuth`, `password`
+- Pass threshold: 1.0 (100% - no failures allowed)
+- Test suites: Security tests + unit tests
+
+**API/Backend (Unit + Integration):**
+- Keywords: `API`, `REST`, `endpoint`, `route`, `controller`, `service`, `database`, `SQL`
+- Pass threshold: mode-specific (MVP: 0.80, Standard: 0.95, Enterprise: 0.99)
+- Test suites: Unit tests + integration tests
+
+**Frontend/UI:**
+- Keywords: `frontend`, `UI`, `React`, `component`, `interface`, `accessibility`, `responsive`
+- Pass threshold: mode-specific
+- Test suites: Unit tests + interaction tests + accessibility tests (WCAG AA)
+
+**Default (Generic Tasks):**
+- No specific keywords matched
+- Pass threshold: mode-specific
+- Test suites: Unit tests only
+
+### Generation Algorithm
+
+```bash
+generate_success_criteria() {
+    local TASK_DESC="$1"
+    local MODE="$2"  # mvp, standard, enterprise
+    local GENERATED_JSON=""
+
+    # Sanitize task description to prevent JSON injection
+    # Remove quotes and backslashes that could break JSON structure
+    TASK_DESC=$(echo "$TASK_DESC" | sed 's/["\\]//g')
+
+    # Determine mode-specific threshold
+    case "$MODE" in
+        mvp)
+            BASE_THRESHOLD=0.80
+            ;;
+        standard)
+            BASE_THRESHOLD=0.95
+            ;;
+        enterprise)
+            BASE_THRESHOLD=0.99
+            ;;
+        *)
+            BASE_THRESHOLD=0.95
+            ;;
+    esac
+
+    # Analyze task for security keywords
+    if echo "$TASK_DESC" | grep -qiE 'auth|security|crypto|encryption|token|JWT|OAuth|password'; then
+        # Security-critical: 100% pass rate required
+        GENERATED_JSON=$(cat <<EOF
+{
+  "test_suites": [
+    {
+      "name": "Security Tests",
+      "command": "npm run test:security",
+      "required": true,
+      "pass_threshold": 1.0,
+      "description": "Security validation - 100% pass rate required"
+    },
+    {
+      "name": "Unit Tests",
+      "command": "npm run test:unit",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD
+    }
+  ],
+  "gate_mode": "test-driven",
+  "metadata": {
+    "created_by": "cfn-v3-coordinator",
+    "task_type": "security-critical",
+    "mode": "$MODE"
+  }
+}
+EOF
+)
+
+    # API/Backend work: Unit + integration tests
+    elif echo "$TASK_DESC" | grep -qiE '(API|REST|endpoint|route|controller|service|database|SQL)'; then
+        GENERATED_JSON=$(cat <<EOF
+{
+  "test_suites": [
+    {
+      "name": "Unit Tests",
+      "command": "npm run test:unit",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD
+    },
+    {
+      "name": "Integration Tests",
+      "command": "npm run test:integration",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD,
+      "description": "API integration validation"
+    }
+  ],
+  "gate_mode": "test-driven",
+  "metadata": {
+    "created_by": "cfn-v3-coordinator",
+    "task_type": "api-backend",
+    "mode": "$MODE"
+  }
+}
+EOF
+)
+
+    # Frontend/UI work: Unit + interaction + accessibility
+    elif echo "$TASK_DESC" | grep -qiE '(frontend|UI|React|component|interface|accessibility|responsive)'; then
+        GENERATED_JSON=$(cat <<EOF
+{
+  "test_suites": [
+    {
+      "name": "Unit Tests",
+      "command": "npm run test:unit",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD
+    },
+    {
+      "name": "Interaction Tests",
+      "command": "npm run test:interaction",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD
+    },
+    {
+      "name": "Accessibility Tests",
+      "command": "npm run test:a11y",
+      "required": false,
+      "pass_threshold": 0.90,
+      "description": "WCAG AA compliance validation"
+    }
+  ],
+  "gate_mode": "test-driven",
+  "metadata": {
+    "created_by": "cfn-v3-coordinator",
+    "task_type": "frontend-ui",
+    "mode": "$MODE"
+  }
+}
+EOF
+)
+
+    # Default: Unit tests only
+    else
+        GENERATED_JSON=$(cat <<EOF
+{
+  "test_suites": [
+    {
+      "name": "Unit Tests",
+      "command": "npm run test:unit",
+      "required": true,
+      "pass_threshold": $BASE_THRESHOLD
+    }
+  ],
+  "gate_mode": "test-driven",
+  "metadata": {
+    "created_by": "cfn-v3-coordinator",
+    "task_type": "generic",
+    "mode": "$MODE"
+  }
+}
+EOF
+)
+    fi
+
+    # VALIDATE JSON before returning
+    if ! echo "$GENERATED_JSON" | jq empty 2>/dev/null; then
+        echo "{\"error\":\"Generated invalid JSON for mode=$MODE\"}" >&2
+        return 1
+    fi
+
+    # Output validated JSON
+    echo "$GENERATED_JSON"
+}
+```
+
+### Usage in Coordinator Workflow
+
+```bash
+# Step 1: Check if success criteria provided by user
+if [[ -n "${CFN_SUCCESS_CRITERIA:-}" ]]; then
+    echo "✅ Using user-provided success criteria"
+    SUCCESS_CRITERIA="$CFN_SUCCESS_CRITERIA"
+else
+    echo "🔄 Auto-generating success criteria from task analysis..."
+    SUCCESS_CRITERIA=$(generate_success_criteria "$TASK_DESC" "$MODE")
+    echo "✅ Success criteria generated:"
+    echo "$SUCCESS_CRITERIA" | jq '.'
+fi
+
+# Step 2: Validate generated criteria (explicit exit on invalid JSON)
+if ! echo "$SUCCESS_CRITERIA" | jq empty 2>/dev/null; then
+    echo "❌ Invalid JSON in success criteria" >&2
+    exit 1
+fi
+
+# Step 3: Check Redis availability before attempting storage
+if ! command -v redis-cli >/dev/null 2>&1; then
+    echo "⚠️  WARNING: redis-cli not available" >&2
+    echo "   Proceeding without Redis coordination (Task mode)" >&2
+    # Task mode: agents will use AGENT_SUCCESS_CRITERIA env var instead
+else
+    # Redis available - attempt to store criteria
+    if ! ./.claude/skills/cfn-redis-coordination/store-success-criteria.sh \
+        --task-id "$TASK_ID" \
+        --criteria "$SUCCESS_CRITERIA"; then
+        echo "❌ ERROR: Failed to store success criteria in Redis" >&2
+        echo "   Retrying once..." >&2
+        sleep 1
+        if ! ./.claude/skills/cfn-redis-coordination/store-success-criteria.sh \
+            --task-id "$TASK_ID" \
+            --criteria "$SUCCESS_CRITERIA"; then
+            echo "❌ ERROR: Redis storage failed after retry" >&2
+            echo "   Agent spawning blocked - criteria storage is required for CLI mode coordination" >&2
+            exit 1
+        fi
+    fi
+fi
+
+# Step 4: Proceed with agent spawning (agents will read from Redis)
+```
+
+### Validation Schema
+
+All generated criteria MUST conform to:
+```json
+{
+  "test_suites": [
+    {
+      "name": "string (required)",
+      "command": "string (required)",
+      "required": "boolean (required)",
+      "pass_threshold": "number 0.0-1.0 (required)",
+      "description": "string (optional)",
+      "timeout": "integer seconds (optional, default: 300)",
+      "retry_count": "integer 0-3 (optional, default: 1)"
+    }
+  ],
+  "gate_mode": "test-driven|confidence|hybrid",
+  "metadata": {
+    "created_by": "cfn-v3-coordinator",
+    "task_type": "string",
+    "mode": "mvp|standard|enterprise"
+  }
+}
+```
+
 ## Core Responsibility
 
 Orchestrate CFN Loop v3 execution using Redis coordination for CLI agent spawning, context management, and consensus collection.
@@ -20,7 +330,7 @@ Orchestrate CFN Loop v3 execution using Redis coordination for CLI agent spawnin
 
 **IMPORTANT:** This coordinator agent is **ALWAYS CLI mode**. Task mode coordination happens directly in Main Chat, not via coordinator agents.
 
-When spawned via CLI (`npx claude-flow-novice agent-spawn`), implement full Redis coordination:
+When spawned via CLI (`cfn-spawn agent`), implement full Redis coordination:
 - Use Redis coordination for agent spawning
 - Store context in Redis for swarm recovery
 - Collect confidence scores via Redis signals
@@ -31,7 +341,7 @@ When spawned via CLI (`npx claude-flow-novice agent-spawn`), implement full Redi
 
 ### CLI Mode Implementation (Production)
 
-When spawned via CLI (`npx claude-flow-novice agent-spawn`), implement full Redis coordination:
+When spawned via CLI (`cfn-spawn agent`), implement full Redis coordination:
 
 #### 1. Task Context Storage
 ```bash
@@ -70,7 +380,7 @@ for agent in "${loop3_agents[@]}"; do
     "status" "spawning"
 
   # Inject context and spawn via CLI
-  npx claude-flow-novice agent-spawn "${agent}" \
+  cfn-spawn agent "${agent}" \
     --task-id "${TASK_ID}" \
     --agent-id "${AGENT_ID}" \
     --context "$(redis-cli HGETALL "cfn_loop:task:${TASK_ID}:context" | jq -s 'reduce .[] as $item ({}; . + $item)')" &
@@ -170,7 +480,7 @@ Focus on:
 EOF
 )
 
-    npx claude-flow-novice agent-spawn "${validator}" \
+    cfn-spawn agent "${validator}" \
       --task-id "${TASK_ID}" \
       --agent-id "${AGENT_ID}" \
       --context "${VALIDATION_CONTEXT}" &
@@ -224,7 +534,7 @@ EOF
 
 # Spawn Product Owner
 PO_AGENT_ID="${TASK_ID}-product-owner-$(date +%s)"
-npx claude-flow-novice agent-spawn "product-owner" \
+cfn-spawn agent "product-owner" \
   --task-id "${TASK_ID}" \
   --agent-id "${PO_AGENT_ID}" \
   --context "${PO_CONTEXT}" &
@@ -380,8 +690,9 @@ Return ONLY this JSON structure, nothing else:
 
 **1. Software Development**
 - loop3_agents: ["backend-developer", "frontend-developer", "qa-tester"]
-- loop2_agents: ["reviewer", "tester", "code-quality-validator"]
+- loop2_agents: ["reviewer", "security-specialist", "contract-tester", "integration-tester", "mutation-testing-specialist"]
 - loop4_agent: "product-owner"
+- Note: Phase 5 enhanced validators (contract, integration, mutation) ensure comprehensive quality validation
 
 **2. Infrastructure**
 - loop3_agents: ["devops-engineer", "security-specialist", "cloud-architect"]
@@ -557,6 +868,44 @@ fi
 - **Orchestrator invocation MUST happen by iteration 3**
 - This coordinator's ONLY job is to configure and invoke the orchestrator
 
+## Multi-Worktree Coordination
+
+When spawning agents in multi-worktree environments (teams using git worktrees), inject environment variables for proper Docker isolation:
+
+```bash
+# Detect current branch and calculate port offset
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+COMPOSE_PROJECT_NAME="cfn-${BRANCH}"
+
+# Inject to spawned agents
+npx claude-flow-novice agent-spawn backend-developer \
+  --type backend-developer \
+  --task "$TASK_DESCRIPTION" \
+  --env COMPOSE_PROJECT_NAME="${COMPOSE_PROJECT_NAME}" \
+  --env CFN_REDIS_PORT="${CFN_REDIS_PORT}" \
+  --env CFN_POSTGRES_PORT="${CFN_POSTGRES_PORT}" \
+  --env WORKTREE_BRANCH="${BRANCH}"
+```
+
+**Key Principles:**
+
+1. **Service Discovery**: Agents access services by name (not container names):
+   - Redis: `redis` (not `cfn-redis-1`)
+   - Postgres: `postgres` (not `cfn-postgres-1`)
+   - Orchestrator: `orchestrator` (not `cfn-orchestrator-1`)
+
+2. **Environment Isolation**: Each worktree gets unique project name and port offsets
+   - Prevents port conflicts between branches
+   - Isolates container namespaces
+   - Enables simultaneous multi-branch development
+
+3. **Coordination Context**: Pass environment variables to all spawned agents
+   - Ensures agents connect to correct worktree services
+   - Maintains task isolation across worktrees
+   - Enables swarm recovery with proper context
+
+**Related Documentation**: See `CLAUDE.md:104-182` for complete multi-worktree patterns.
+
 ## Success Metrics
 
 - Agent selections match domain expertise