claude-flow-novice 2.15.8 → 2.15.9

package/.claude/skills/cfn-loop-orchestration/helpers/consensus-ts.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Consensus Checker (TypeScript Wrapper)
+# Collects and validates Loop 2 consensus scores
+#
+# Usage:
+#   consensus-ts.sh --scores <score1,score2,...> \
+#                   --threshold <0.0-1.0> \
+#                   --mode <mvp|standard|enterprise>
+#
+# Returns:
+#   Exit 0: Consensus reached
+#   Exit 1: Consensus failed
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+SCORES=""
+THRESHOLD=""
+MODE="standard"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --scores) SCORES="$2"; shift 2 ;;
+    --threshold) THRESHOLD="$2"; shift 2 ;;
+    --mode) MODE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$SCORES" ]; then
+  echo "Error: Missing required parameter --scores" >&2
+  exit 1
+fi
+
+# Convert comma-separated scores to JSON array
+IFS=',' read -ra SCORE_ARRAY <<< "$SCORES"
+SCORES_JSON="["
+for i in "${!SCORE_ARRAY[@]}"; do
+  if [ $i -gt 0 ]; then
+    SCORES_JSON+=","
+  fi
+  SCORES_JSON+="${SCORE_ARRAY[$i]}"
+done
+SCORES_JSON+="]"
+
+# Build TypeScript invocation
+TS_CODE="
+import { collectConsensus, validateConsensus } from './consensus';
+
+const scores = $SCORES_JSON;
+const mode = '$MODE';
+const threshold = ${THRESHOLD:-null};
+
+try {
+  const consensus = collectConsensus(scores);
+  console.log(\`Consensus Statistics:\`);
+  console.log(\`  Count: \${consensus.count}\`);
+  console.log(\`  Average: \${consensus.average.toFixed(3)}\`);
+  console.log(\`  Min: \${consensus.min.toFixed(3)}\`);
+  console.log(\`  Max: \${consensus.max.toFixed(3)}\`);
+  console.log();
+
+  const validationParams: any = {
+    average: consensus.average,
+    mode
+  };
+  if (threshold !== null) {
+    validationParams.threshold = threshold;
+  }
+  const validation = validateConsensus(validationParams);
+
+  console.log(\`Consensus Validation:\`);
+  console.log(\`  Mode: \${validation.mode}\`);
+  console.log(\`  Threshold: \${validation.threshold.toFixed(2)}\`);
+  console.log(\`  Average: \${validation.average.toFixed(3)}\`);
+  console.log(\`  Gap: \${validation.gap >= 0 ? '+' : ''}\${validation.gap.toFixed(3)}\`);
+  console.log(\`  Passed: \${validation.passed}\`);
+  console.log();
+
+  if (validation.passed) {
+    console.log('✅ Consensus REACHED - Loop 2 validation successful');
+    process.exit(0);
+  } else {
+    console.log('❌ Consensus FAILED - Iteration required');
+    process.exit(1);
+  }
+} catch (error: any) {
+  console.error('Error:', error.message);
+  process.exit(2);
+}
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/.claude/skills/cfn-loop-orchestration/helpers/deliverable-verifier-ts.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Deliverable Verifier (TypeScript Wrapper)
+# Verifies expected deliverables exist (prevents "consensus on vapor")
+#
+# Usage:
+#   deliverable-verifier-ts.sh --files <file1,file2,...> \
+#                              [--expected-types <.ext1,.ext2,...>] \
+#                              [--task-type <description>] \
+#                              [--require-git-changes]
+#
+# Returns:
+#   Exit 0: Deliverables verified
+#   Exit 1: Missing deliverables or validation failed
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+FILES=""
+EXPECTED_TYPES=""
+TASK_TYPE=""
+REQUIRE_GIT_CHANGES="false"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --files) FILES="$2"; shift 2 ;;
+    --expected-types) EXPECTED_TYPES="$2"; shift 2 ;;
+    --task-type) TASK_TYPE="$2"; shift 2 ;;
+    --require-git-changes) REQUIRE_GIT_CHANGES="true"; shift 1 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Convert comma-separated files to JSON array
+if [ -n "$FILES" ]; then
+  IFS=',' read -ra FILE_ARRAY <<< "$FILES"
+  FILES_JSON="["
+  for i in "${!FILE_ARRAY[@]}"; do
+    if [ $i -gt 0 ]; then
+      FILES_JSON+=","
+    fi
+    FILES_JSON+="\"${FILE_ARRAY[$i]}\""
+  done
+  FILES_JSON+="]"
+else
+  FILES_JSON="[]"
+fi
+
+# Convert comma-separated types to JSON array
+if [ -n "$EXPECTED_TYPES" ]; then
+  IFS=',' read -ra TYPE_ARRAY <<< "$EXPECTED_TYPES"
+  TYPES_JSON="["
+  for i in "${!TYPE_ARRAY[@]}"; do
+    if [ $i -gt 0 ]; then
+      TYPES_JSON+=","
+    fi
+    TYPES_JSON+="\"${TYPE_ARRAY[$i]}\""
+  done
+  TYPES_JSON+="]"
+else
+  TYPES_JSON="undefined"
+fi
+
+# Build TypeScript invocation
+TS_CODE="
+import { verifyDeliverables } from './deliverable-verifier';
+
+const result = verifyDeliverables({
+  files: $FILES_JSON,
+  ${EXPECTED_TYPES:+expectedTypes: $TYPES_JSON,}
+  ${TASK_TYPE:+taskType: '$TASK_TYPE',}
+  requireGitChanges: $REQUIRE_GIT_CHANGES
+});
+
+console.log('Deliverable Verification:');
+console.log(\`  Files checked: \${result.files.length}\`);
+console.log(\`  Found: \${result.found.length}\`);
+console.log(\`  Missing: \${result.missing.length}\`);
+if (result.gitChanges !== undefined) {
+  console.log(\`  Git changes: \${result.gitChanges}\`);
+}
+console.log();
+
+if (result.found.length > 0) {
+  console.log('Found files:');
+  result.found.forEach(file => console.log(\`  ✅ \${file}\`));
+  console.log();
+}
+
+if (result.missing.length > 0) {
+  console.log('Missing files:');
+  result.missing.forEach(file => console.log(\`  ❌ \${file}\`));
+  console.log();
+}
+
+if (result.typeErrors && result.typeErrors.length > 0) {
+  console.log('Type errors:');
+  result.typeErrors.forEach(file => console.log(\`  ⚠️  \${file}\`));
+  console.log();
+}
+
+if (result.verified) {
+  console.log('✅ Deliverable verification PASSED');
+  process.exit(0);
+} else {
+  console.log('❌ Deliverable verification FAILED');
+  if (result.reason) {
+    console.log(\`   Reason: \${result.reason}\`);
+  }
+  process.exit(1);
+}
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/.claude/skills/cfn-loop-orchestration/helpers/iteration-manager-ts.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Iteration Manager (TypeScript Wrapper)
+# Prepares next iteration and generates wake signals
+#
+# Usage:
+#   iteration-manager-ts.sh --current-iteration <n> \
+#                           --agents <agent1,agent2,...> \
+#                           [--feedback <json>]
+#
+# Returns:
+#   Next iteration metadata (JSON)
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+CURRENT_ITERATION=""
+AGENTS=""
+FEEDBACK="{}"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --current-iteration) CURRENT_ITERATION="$2"; shift 2 ;;
+    --agents) AGENTS="$2"; shift 2 ;;
+    --feedback) FEEDBACK="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Validation
+if [ -z "$CURRENT_ITERATION" ] || [ -z "$AGENTS" ]; then
+  echo "Error: Missing required parameters" >&2
+  exit 1
+fi
+
+# Convert comma-separated agents to JSON array
+IFS=',' read -ra AGENT_ARRAY <<< "$AGENTS"
+AGENTS_JSON="["
+for i in "${!AGENT_ARRAY[@]}"; do
+  if [ $i -gt 0 ]; then
+    AGENTS_JSON+=","
+  fi
+  AGENTS_JSON+="\"${AGENT_ARRAY[$i]}\""
+done
+AGENTS_JSON+="]"
+
+# Build TypeScript invocation
+TS_CODE="
+import { prepareIteration, wakeAgents } from './iteration-manager';
+
+const iteration = prepareIteration({
+  currentIteration: $CURRENT_ITERATION,
+  feedback: $FEEDBACK
+});
+
+console.log('Iteration Preparation:');
+console.log(\`  Next Iteration: \${iteration.nextIteration}\`);
+console.log(\`  Timestamp: \${iteration.timestamp}\`);
+console.log();
+
+const agentIds = $AGENTS_JSON;
+const wake = wakeAgents(agentIds);
+
+console.log('Wake Signals Generated:');
+wake.signals.forEach((signal, idx) => {
+  console.log(\`  [\${idx + 1}] \${signal}\`);
+});
+console.log();
+console.log(\`✅ Prepared iteration \${iteration.nextIteration} for \${agentIds.length} agents\`);
+
+// Output JSON for programmatic consumption
+console.log();
+console.log('JSON_OUTPUT:', JSON.stringify({
+  nextIteration: iteration.nextIteration,
+  timestamp: iteration.timestamp,
+  signals: wake.signals
+}));
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

package/.claude/skills/cfn-loop-orchestration/helpers/timeout-calculator-ts.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# Timeout Calculator (TypeScript Wrapper)
+# Calculates mode and phase-specific timeouts for agent execution
+#
+# Usage:
+#   timeout-calculator-ts.sh --mode <mvp|standard|enterprise> [--phase <phase-id>]
+#
+# Returns:
+#   Timeout value in seconds (stdout)
+##############################################################################
+
+set -euo pipefail
+
+# Get script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HELPERS_DIR="$SCRIPT_DIR/../src/helpers"
+
+# Parameters
+MODE="standard"
+PHASE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --mode) MODE="$2"; shift 2 ;;
+    --phase) PHASE="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 1 ;;
+  esac
+done
+
+# Build TypeScript invocation
+TS_CODE="
+import { calculateTimeout } from './timeout-calculator';
+
+const timeout = calculateTimeout({
+  mode: '$MODE',
+  ${PHASE:+phase: '$PHASE'}
+});
+
+console.log(timeout);
+"
+
+# Execute TypeScript code
+cd "$HELPERS_DIR"
+ts-node -e "$TS_CODE"

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/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
 

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

@@ -440,6 +440,8 @@ When spawned via Task() tool in Main Chat:
 Complete your consensus-building 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")
@@ -448,7 +450,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
 

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

@@ -529,6 +529,8 @@ echo "CONFIDENCE: [0.0-1.0]"
 Complete your handoff 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")
@@ -537,7 +539,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
 

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

@@ -470,6 +470,8 @@ When spawned via Task() tool in Main Chat:
 Complete your multi-sprint 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")
@@ -478,7 +480,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
 

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

@@ -624,16 +624,26 @@ networks:
 Complete your work and provide test-based validation:
 
 1. **Execute Tests**: Run all test suites from success criteria
-# 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")
-TOTAL=$((PASS + FAIL))
-RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
-
-# Return results (Main Chat receives automatically in Task Mode)
-echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
+   ```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")
+   TOTAL=$((PASS + FAIL))
+   RATE=$(awk "BEGIN {if ($TOTAL > 0) printf \"%.2f\", $PASS/$TOTAL; else print \"0.00\"}")
+
+   # Return results (Main Chat receives automatically in Task Mode)
+   echo "{\"passed\": $PASS, \"failed\": $FAIL, \"pass_rate\": $RATE}"
+   ```
+
+2. **Parse Results**: Extract test counts and calculate pass rate
+
+3. **Coverage Check**: Ensure coverage meets minimum thresholds
+   - Build tests: ≥95%
+   - Security tests: ≥90%
    - Coverage: ≥80%
+
 4. **Store in Redis**: Use test-results key (not confidence key)
+
 5. **Signal Completion**: Push to completion queue
 
 **Example Report:**