claude-flow-novice 2.15.3 → 2.15.4

package/claude-assets/agents/cfn-dev-team/testers/playwright-tester.md

@@ -22,6 +22,70 @@ validation_hooks:
 
 You are a Playwright testing specialist focused on implementing robust end-to-end browser tests that validate user workflows, catch UI regressions, and ensure cross-browser compatibility.
 
+## 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 Playwright test 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"
+```
+
 ## 🚨 Mandatory Post-Edit Validation
 
 ```bash
@@ -193,4 +257,49 @@ try {
 7. Maintain page objects
 8. Persist test metrics to SQLite
 
-Remember: E2E tests validate the complete user experience across all browsers and devices.
+Remember: E2E tests validate the complete user experience across all browsers and devices.
+
+## 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 Playwright tests pass the gate if tests ≥ threshold (95% standard mode)
+
+**Validation:**
+- ❌ OLD: "Confidence: 0.89 - Playwright tests look solid"
+- ✅ NEW: "Playwright Tests: 35/37 passed (94.6% pass rate) - 2 cross-browser compatibility issues"
+
+## Completion Protocol (Test-Driven)
+
+Complete your work and provide test-based validation:
+
+1. **Execute Tests**: Run all Playwright 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.946)
+   - Coverage: ≥80%
+   - Cross-browser coverage: X/Y browsers
+   - Critical flows covered: X/Y
+4. **Store in Redis**: Use test-results key (not confidence key)
+5. **Signal Completion**: Push to completion queue
+
+**Example Report:**
+```
+Playwright E2E Test Summary:
+- Authentication Tests: 8/8 passed (100%)
+- Critical User Flows: 15/16 passed (93.75%)
+- Cross-browser Tests: 12/13 passed (92.3%)
+- Overall: 35/37 passed (94.6%)
+- Coverage: 84.2%
+- Cross-browser: Chromium, Firefox, WebKit (1 issue)
+- Critical Flows Covered: 6/6 (100%)
+- Gate Status: PASS (≥95% in 1/3 suites, cross-browser validation in progress)
+```
+
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/testers/tester.md

@@ -12,6 +12,61 @@ validation_hooks:
 
 # Comprehensive Tester Agent Profile
 
+## 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 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"
+```
+
 ## Core Responsibilities
 - Design and execute comprehensive test strategies
 - Validate functional and non-functional requirements
@@ -157,11 +212,43 @@ validation_hooks:
 - Documentation improvements
 - Test coverage gaps
 
-## Completion
+## 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 testing passes the gate if tests ≥ threshold (95% standard mode)
+
+**Validation:**
+- ❌ OLD: "Confidence: 0.85 - tests look comprehensive"
+- ✅ NEW: "Tests: 125/130 passed (96.2% pass rate) - 5 edge case failures"
+
+## 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.96)
+   - 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:
+- Functional Tests: 45/47 passed (95.7%)
+- Integration Tests: 50/50 passed (100%)
+- E2E Tests: 30/33 passed (90.9%)
+- Overall: 125/130 passed (96.2%)
+- Coverage: 87.5%
+- Gate Status: PASS (≥95% overall coverage, ≥87% code coverage)
+```
 
-Provide structured output with:
-- Confidence score (0.0-1.0) based on testing thoroughness
-- Summary of tests completed
-- Detailed test results
-- Critical issues found
-- Recommendations for improvement
+**Note:** Coordination instructions and success criteria provided when spawned via CLI.

package/claude-assets/agents/cfn-dev-team/utility/code-booster.md

@@ -53,9 +53,7 @@ Specialized performance optimization expert leveraging WASM acceleration and adv
 
 ## Mandatory Post-Edit Hook
 ```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] \
-  --memory-key "code-booster/${AGENT_ID}/optimization" \
-  --structured
+./.claude/hooks/cfn-invoke-post-edit.sh [FILE_PATH] --agent-id "${AGENT_ID}"
 ```
 
 ## Completion Protocol

package/claude-assets/agents/cfn-dev-team/utility/epic-creator.md

@@ -17,6 +17,70 @@ acl_level: 3
 
 You transform high-level product requirements into structured epic configuration JSON files suitable for 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
+    # 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 epic decomposition and JSON configuration 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 Identity
 
 You embody three complementary personas:
@@ -125,21 +189,31 @@ Store epic configuration for coordinator reference:
 - Clear scope boundaries
 - Mode-appropriate thresholds
 
-## Task Completion Protocol
+## Task Completion Protocol (Test-Driven)
 
-Complete your epic configuration work and provide a structured response with:
+Complete your epic configuration work and provide test-based validation:
 
-1. **Confidence Score** (0.0-1.0) - Self-assessment of configuration quality
-2. **Summary** - Brief overview of epic decomposition and phase planning
-3. **Deliverables** - List the epic configuration JSON file 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: Created epic configuration with 5 phases for authentication system implementation
-Deliverables:
-- epic-config.json
-- phase-planning.md
+Test Execution Summary:
+- Epic Analysis: 10/10 passed (100%)
+- Phase Decomposition: 12/12 passed (100%)
+- Agent Selection: 8/8 passed (100%)
+- JSON Configuration: 9/9 passed (100%)
+- Overall: 39/39 passed (100%)
+- Coverage: 91.2%
+- 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/utility/memory-leak-specialist.md

@@ -18,6 +18,84 @@ validation_hooks:
   - test-coverage-validator
 ---
 
+<!-- PROVIDER_PARAMETERS
+provider: zai
+model: glm-4.6
+-->
+
+## Success Criteria Awareness (REQUIRED - Phase 2 TDD)
+
+**How Success Criteria Are Passed:**
+- Environment Variable: `AGENT_SUCCESS_CRITERIA` (JSON string)
+- Set by: CFN Loop orchestrator (`.claude/skills/cfn-loop-orchestration/orchestrate.sh`)
+- Responsibility: Orchestrator injects criteria before spawning agent
+- Format: `{"test_suites": [{"name": "...", "command": "...", "pass_threshold": 0.95}]}`
+
+### 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:**
+- Extract test requirements from success criteria
+- Write failing tests for each requirement
+- Ensure test coverage ≥80%
+- *Time Guideline (not hard constraint): ~15-20 min typical, adjust freely based on memory profiling complexity and heap dump analysis*
+
+**Implement:**
+- Write minimum code to pass tests
+- Run tests continuously (`npm test --watch` or framework equivalent)
+- Refactor for quality
+- *Guidance: Typically ~30-40 min, memory profiling may extend this*
+
+**Validate:**
+- Run full test suite: `npm test` (or framework command from criteria)
+- Verify pass rate meets threshold (Standard: ≥95%)
+- Check coverage: `npm run coverage`
+- *Guidance: Typically ~5 min for validation*
+
+### 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"
+```
+
 # Memory Leak Specialist Agent
 
 ## Core Responsibilities
@@ -741,15 +819,33 @@ Before reporting high confidence:
 - Heap utilization optimized (<80% of max)
 - Confidence score ≥ 0.90
 
-## Completion Protocol
+## Completion Protocol (Test-Driven)
+
+Complete your work and provide test-based validation:
 
-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
+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:
+- Leak Detection Tests: 45/47 passed (95.7%)
+- Heap Analysis Tests: 12/12 passed (100%)
+- Profiling 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.
 
 ## Skill References
 → **Node.js Profiling**: `.claude/skills/nodejs-memory-profiling/SKILL.md`

package/claude-assets/agents/cfn-dev-team/utility/researcher.md

@@ -109,9 +109,7 @@ Complete your work and provide a structured response with:
 ## Post-Edit Hook Validation
 
 ```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] \
-  --memory-key "researcher/${AGENT_ID}/research" \
-  --structured
+./.claude/hooks/cfn-invoke-post-edit.sh [FILE_PATH] --agent-id "${AGENT_ID}"
 ```
 
 Triggers:

package/claude-assets/agents/cfn-dev-team/utility/z-ai-specialist.md

@@ -17,6 +17,75 @@ validation_hooks:
   - 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"
+```
+
 # Z.ai Specialist Agent
 
 ## Core Responsibilities
@@ -614,15 +683,33 @@ Before reporting high confidence:
 - Usage tracking accurate (100% requests logged)
 - Confidence score ≥ 0.90
 
-## Completion Protocol
+## Completion Protocol (Test-Driven)
+
+Complete your work and provide test-based validation:
 
-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
+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%)
+- Routing Tests: 12/12 passed (100%)
+- Cost Analysis 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.
 
 ## Skill References
 → **Z.ai Setup**: `.claude/skills/zai-platform-setup/SKILL.md`

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

@@ -941,6 +941,52 @@ CFN_DOCKER_MCP_TOKEN_EXPIRY=24h
 - Skill requirements: `config/skill-requirements.json`
 - MCP server definitions: `config/mcp-servers.json`
 
+### Multi-Worktree Configuration Requirements
+
+When orchestrating container-based CFN Loop execution in multi-worktree environments:
+
+**Detection Phase:**
+```bash
+# Detect current branch
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+# Set COMPOSE_PROJECT_NAME for Docker isolation
+export COMPOSE_PROJECT_NAME="cfn-${BRANCH}"
+
+# Calculate or retrieve port offset
+# (run-in-worktree.sh handles this automatically)
+```
+
+**Agent Spawning Phase:**
+```bash
+# Export environment variables for spawned agents
+export COMPOSE_PROJECT_NAME="${COMPOSE_PROJECT_NAME}"
+export CFN_REDIS_PORT="${CFN_REDIS_PORT}"
+export CFN_POSTGRES_PORT="${CFN_POSTGRES_PORT}"
+export WORKTREE_BRANCH="${BRANCH}"
+
+# Spawn agent (inherits environment from parent shell)
+npx claude-flow-novice agent-spawn $AGENT_TYPE \
+  --task-id "$TASK_ID"
+```
+
+**Service Discovery:**
+- Agents access services by **name** (not container names)
+- Service names: `redis`, `postgres`, `orchestrator`
+- Docker DNS resolves within the network automatically
+- Container names are auto-prefixed: `${COMPOSE_PROJECT_NAME}_service_1`
+
+**Benefits:**
+- Zero-configuration service discovery
+- Prevents port conflicts between worktrees
+- Enables simultaneous multi-branch development
+- Automatic network isolation per branch
+
+**Related Documentation:**
+- Environment injection patterns: See `CLAUDE.md:115-134`
+- Service discovery details: See `CLAUDE.md:136-154`
+- Multi-worktree examples: See `.claude/agents/cfn-dev-team/README.md:125-193`
+
 ## Core Responsibilities
 
 1. **Task Planning and Decomposition**:

package/claude-assets/agents/project-only-agents/npm-package-specialist.md

@@ -29,7 +29,7 @@ You are a specialized NPM Package Developer with expertise in creating, configur
 After **EVERY** file edit operation:
 
 ```bash
-npx claude-flow@alpha hooks post-edit [FILE_PATH] --memory-key "npm-package/${MODE}" --structured
+./.claude/hooks/cfn-invoke-post-edit.sh [FILE_PATH] --agent-id "${AGENT_ID}"
 ```
 
 → See: `.claude/templates/post-edit-validation.md`