claude-flow-novice 2.18.6 → 2.18.7

package/.claude/skills/cfn-loop-orchestration-v2/lib/validation/SKILL.md.backup

@@ -1,353 +0,0 @@
-# CFN Loop Validation Skill
-
-**Purpose:** Implement multi-layer validation and quality gates for CFN Loop workflows with clean agent exit patterns.
-
-**Version:** 2.3.0  
-**Confidence:** 0.98  
-**Status:** Production Ready (Robustness Enhanced)
-
----
-
-## Core Architecture
-
-### Clean Agent Exit Protocol
-
-**Critical Principle:** Agents MUST exit immediately after reporting confidence. No waiting mode for implementers/validators.
-
-```bash
-# ✅ CORRECT - Agent completion protocol
-# Step 1: Complete work
-# Step 2: Signal completion
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-
-# Step 3: Report confidence
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.85 \
-  --iteration 1
-
-# Step 4: EXIT CLEANLY (no waiting mode)
-# Agent process terminates here
-```
-
-```bash
-# ❌ FORBIDDEN - Agents entering waiting mode
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "${AGENT_ID}" \
-  --context "iteration-complete"
-```
-
-**Why Clean Exit Matters:**
-- Prevents orchestrator blocking on `wait $PID`
-- Enables adaptive agent specialization (different agents per iteration)
-- Eliminates indefinite blocking scenarios
-- Supports true parallel execution
-
-### Validation Layers
-
-#### Layer 1: Gate Validation (Loop 3 Self-Validation)
-- **Threshold:** Mode-dependent (0.70-0.85)
-- **Purpose:** Implementers self-assess work quality
-- **Blocking:** Prevents validators from reviewing incomplete work
-
-#### Layer 2: Consensus Validation (Loop 2 Validators)
-- **Threshold:** Mode-dependent (0.80-0.95)
-- **Purpose:** Independent quality assessment
-- **Requirement:** Minimum 2 validators for robust consensus
-
-#### Layer 3: Product Owner Decision
-- **Purpose:** Strategic validation and scope enforcement
-- **Options:** PROCEED/ITERATE/ABORT
-- **Anti-Pattern Prevention:** Prevents "consensus on vapor"
-
-### Dependency Enforcement
-
-**Mandatory Flow:**
-1. Loop 3 agents complete work
-2. Gate check validates Loop 3 quality
-3. **IF gate passes →** Signal `swarm:${TASK_ID}:gate-passed`
-4. Loop 2 validators wait for gate signal via `blpop`
-5. Loop 2 validators review and report consensus
-6. Product Owner makes final decision
-
-**Redis Coordination:**
-```bash
-# Loop 2 agents wait for gate signal
-redis-cli blpop "swarm:${TASK_ID}:gate-passed" 0
-
-# Gate signal sent by orchestrator
-redis-cli lpush "swarm:${TASK_ID}:gate-passed" "true"
-```
-
----
-
-## Mode Configurations
-
-### MVP Mode (Fast Validation)
-- **Gate Threshold:** 0.70
-- **Consensus Threshold:** 0.80
-- **Max Iterations:** 5
-- **Validators:** 2
-- **Use Case:** Quick prototyping, proof-of-concepts
-
-### Standard Mode (Balanced Quality)
-- **Gate Threshold:** 0.75
-- **Consensus Threshold:** 0.90
-- **Max Iterations:** 10
-- **Validators:** 3-4
-- **Use Case:** Production features, standard development
-
-### Enterprise Mode (Maximum Quality)
-- **Gate Threshold:** 0.85
-- **Consensus Threshold:** 0.95
-- **Max Iterations:** 15
-- **Validators:** 5
-- **Use Case:** Critical systems, security-sensitive features
-
----
-
-## Agent Lifecycle Management
-
-### Coordinator Responsibilities
-- Spawn agents via CLI (cost optimization)
-- Manage Redis coordination
-- Handle iteration logic
-- Collect confidence scores
-- Enforce dependency blocking
-
-### Agent Responsibilities
-- Complete assigned work
-- Signal completion via Redis
-- Report confidence score
-- **Exit immediately (no waiting mode) - MANDATORY**
-
-### Updated Agent Completion Protocol (v2.3)
-```bash
-# ✅ NEW MANDATORY PROTOCOL - All agents MUST follow
-# Step 1: Complete work
-# Step 2: Signal completion
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-
-# Step 3: Report confidence score
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.92 \
-  --iteration 1
-
-# Step 4: EXIT CLEANLY (no waiting mode - agents MUST NOT enter waiting mode)
-# Agent process terminates here - orchestrator uses wait $PID
-exit 0
-```
-
-### Clean Exit Benefits
-1. **No Blocking:** Orchestrator uses `wait $PID` successfully
-2. **Adaptive Specialization:** Different agents per iteration
-3. **Resource Efficiency:** No idle agent processes
-4. **Simplified Debugging:** Clear agent lifecycle
-5. **Prevents Orchestration Deadlock:** Eliminates indefinite agent blocking
-6. **Enables True Parallelism:** Multiple agents can complete independently
-
-### Forbidden Patterns (Critical Anti-Patterns)
-```bash
-# ❌ FORBIDDEN - Agents MUST NOT enter waiting mode
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \
-  --task-id "$TASK_ID" \
-  --agent-id "${AGENT_ID}" \
-  --context "iteration-complete"
-
-# ❌ FORBIDDEN - Only coordinators use waiting mode
-if [[ "$AGENT_TYPE" != "coordinator" ]]; then
-  echo "ERROR: Non-coordinator agents cannot use waiting mode"
-  exit 1
-fi
-```
-
----
-
-## Context Injection Patterns
-
-### Multi-Layer Context Flow
-```
-Coordinator → Redis Storage → Orchestrator → Agent Spawning → Agent Context
-```
-
-**Critical Requirement:** Context must flow through ALL layers.
-
-#### Context Components
-- **Epic Context:** High-level goals and scope
-- **Phase Context:** Sprint-specific requirements
-- **Success Criteria:** Acceptance criteria and deliverables
-- **Thresholds:** Gate and consensus values
-
-#### Context Validation
-1. **Coordinator:** Validates context has deliverables before spawning
-2. **Orchestrator:** Validates Redis retrieval before agent spawning
-3. **Agents:** Validate received context has required fields
-
-**Anti-Pattern Prevention:** Avoid generic context when specifics exist in Redis.
-
----
-
-## Quality Gates Implementation
-
-### Deliverable Verification (STRAT-020)
-**Mandatory check:** Validate actual file creation for implementation tasks.
-
-```bash
-# Check for deliverable creation
-git_status=$(git status --porcelain 2>/dev/null || echo "")
-if [[ -z "$git_status" ]] && [[ "$task_type" == "implementation" ]]; then
-    # Force iteration - no files created
-    consensus=0.0
-    feedback="No deliverable files created. Must implement actual changes."
-fi
-```
-
-### Confidence Scoring Patterns
-- **Explicit Numeric:** `0.85` (preferred)
-- **Percentage:** `85%` (supported)
-- **Qualitative:** `high/medium/low` (converted to 0.8/0.5/0.2)
-- **Calculated:** Based on deliverable completion
-
-### Multi-Pattern Parsing (PATTERN-009)
-```bash
-# Extract confidence with fallback strategies
-confidence=$(echo "$output" | grep -o "confidence: [0-9.]*" | tail -1 | cut -d' ' -f2)
-if [[ -z "$confidence" ]]; then
-    confidence=$(echo "$output" | grep -o "[0-9]*%" | tail -1 | sed 's/%//')
-    if [[ -n "$confidence" ]]; then
-        confidence=$(echo "scale=2; $confidence/100" | bc -l)
-    fi
-fi
-```
-
----
-
-## Testing and Validation
-
-### Test Suite Requirements
-- Validate clean agent exit
-- Test dependency enforcement
-- Verify context injection
-- Check timeout handling
-- Validate consensus calculations
-
-### Key Test Cases
-1. **Clean Exit Test:** Agents exit without waiting mode
-2. **Blocking Test:** Loop 2 waits for Loop 3 gate signal
-3. **Context Test:** Deliverables flow through all layers
-4. **Iteration Test:** Quality gate triggers iteration
-5. **Timeout Test:** Agents respect phase timeouts
-
----
-
-## Integration Points
-
-### Redis Coordination Skill
-- Uses `invoke-waiting-mode.sh report` for confidence reporting
-- No `enter` calls for implementers/validators
-- Blocking via `blpop` for dependency enforcement
-
-### Agent Spawning Skill
-- CLI spawning for cost optimization
-- Agent ID assignment and tracking
-- Background process management
-
-### Product Owner Decision Skill
-- Structured decision parsing
-- Deliverable validation
-- Scope enforcement
-
----
-
-## Error Handling and Recovery
-
-### Timeout Scenarios
-- **Phase-specific timeouts:** Based on work complexity
-- **Agent timeout:** `timeout` command wrapper
-- **Orchestrator timeout:** Background execution with monitoring
-
-### Failure Recovery
-- **Redis state cleanup:** Clear iteration data
-- **Agent PID tracking:** Monitor and cleanup stuck processes
-- **Context validation:** Fail-fast on missing context
-
----
-
-## Performance Optimization
-
-### Cost Savings
-- **CLI Spawning:** 95-98% cost reduction vs Task()
-- **Zero-Token Waiting:** Redis BLPOP for coordination
-- **Parallel Execution:** Background agent spawning
-
-### Resource Management
-- **Clean Exit:** No idle agent processes
-- **Timeout Enforcement:** Prevent resource leaks
-- **Redis Cleanup:** Automatic state management
-
----
-
-## Usage Examples
-
-### Standard CFN Loop Execution
-```bash
-./.claude/skills/redis-coordination/orchestrate-cfn-loop.sh \
-  --task-id "feature-auth-123" \
-  --mode standard \
-  --loop3-agents "backend-dev,security-specialist" \
-  --loop2-agents "reviewer,tester,architect" \
-  --product-owner "product-owner" \
-  --phase-id "phase-2" \
-  --epic-context '{"epicGoal":"Build auth system","inScope":["JWT","OAuth"]}' \
-  --phase-context '{"deliverables":["auth.js","tests/auth.test.js"]}' \
-  --success-criteria '{"acceptanceCriteria":["JWT tokens work","Tests pass"]}'
-```
-
-### Agent Implementation Protocol
-```bash
-# Agent receives task context
-# Completes implementation work
-
-# Signal completion
-redis-cli lpush "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
-
-# Report confidence
-./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --confidence 0.92 \
-  --iteration 1
-
-# EXIT CLEANLY - no waiting mode
-```
-
----
-
-## Monitoring and Debugging
-
-### Key Redis Keys
-- `swarm:${TASK_ID}:${AGENT_ID}:done` - Completion signal
-- `swarm:${TASK_ID}:${AGENT_ID}:confidence` - Confidence score
-- `swarm:${TASK_ID}:gate-passed` - Gate signal
-- `swarm:${TASK_ID}:epic-context` - Epic context
-- `swarm:${TASK_ID}:success-criteria` - Acceptance criteria
-
-### Debug Commands
-```bash
-# Check agent completion
-redis-cli lrange "swarm:${TASK_ID}:${AGENT_ID}:done" 0 -1
-
-# Check confidence scores
-redis-cli get "swarm:${TASK_ID}:${AGENT_ID}:confidence"
-
-# Monitor gate signals
-redis-cli blpop "swarm:${TASK_ID}:gate-passed" 1
-```
-
----
-
-**Maintenance:** Regular validation of clean exit patterns and dependency enforcement. Test suite should validate all lifecycle scenarios.

package/.claude/skills/cfn-loop-orchestration-v2/lib/validation/check-dependencies.sh.backup

@@ -1,31 +0,0 @@
-#!/bin/bash
-# Dependency checker for CFN Loop Validation
-
-check_command() {
-  if command -v "$1" &> /dev/null; then
-    VERSION=$($1 --version 2>&1 | head -n1)
-    echo "✅ $1: $VERSION"
-    return 0
-  else
-    echo "❌ $1: NOT FOUND"
-    return 1
-  fi
-}
-
-echo "Checking dependencies for CFN Loop Validation..."
-MISSING=0
-
-# Required dependencies
-check_command "bash" || MISSING=$((MISSING+1))
-check_command "jq" || MISSING=$((MISSING+1))
-check_command "bc" || MISSING=$((MISSING+1))
-
-if [ $MISSING -eq 0 ]; then
-  echo ""
-  echo "✅ All required dependencies installed"
-  exit 0
-else
-  echo ""
-  echo "❌ Missing $MISSING required dependencies"
-  exit 1
-fi

package/.claude/skills/cfn-loop-orchestration-v2/lib/validation/detect-vapor.sh.backup

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-##############################################################################
-# Detect Consensus on Vapor - TypeScript Wrapper
-#
-# Detects when agents claim completion but deliverables are missing.
-#
-# Usage:
-#   ./detect-vapor.sh --output "agent_output.txt" --deliverables file1.js,file2.js [--json]
-#   ./detect-vapor.sh --output "Completed the task" --deliverables file1.js,file2.js [--json]
-#
-# Returns JSON with vapor detection result
-# Exit codes:
-#   0 - No vapor detected
-#   1 - Vapor detected
-##############################################################################
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TS_DIST="$SCRIPT_DIR/dist/cli/detect-vapor.js"
-
-# Check if TypeScript implementation exists
-if [ ! -f "$TS_DIST" ]; then
-  echo "Error: TypeScript implementation not found at: $TS_DIST" >&2
-  echo "Run 'npm run build' in $SCRIPT_DIR" >&2
-  exit 1
-fi
-
-# Check if node is available
-if ! command -v node &>/dev/null; then
-  echo "Error: Node.js is required but not found in PATH" >&2
-  exit 1
-fi
-
-# Execute TypeScript implementation
-exec node "$TS_DIST" "$@"

package/.claude/skills/cfn-loop-orchestration-v2/lib/validation/orchestrate-cfn-loop.sh.backup

@@ -1,252 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# CFN Loop Orchestration v1.0.0
-# Manages multi-loop CFN execution with dependency tracking and consensus
-#
-# Usage:
-#   ./orchestrate-cfn-loop.sh --task-id <id> \
-#                             --mode <mvp|standard|enterprise> \
-#                             --loop3-agents <agent1,agent2,...> \
-#                             --loop2-agents <agent1,agent2,...> \
-#                             --product-owner <agent-id> \
-#                             [--max-iterations <n>]
-#
-# CFN Loop Structure:
-#   Loop 3 (Primary Swarm) → Loop 2 (Consensus) → Product Owner Decision
-#
-# Dependency Enforcement:
-#   - Loop 2 agents BLOCK until all Loop 3 agents signal completion
-#   - Product Owner BLOCKS until all Loop 2 agents signal completion
-#   - Uses Redis BLPOP for zero-token waiting
-##############################################################################
-
-set -euo pipefail
-
-# Configuration
-TASK_ID=""
-MODE="standard"
-LOOP3_AGENTS=""
-LOOP2_AGENTS=""
-PRODUCT_OWNER=""
-MAX_ITERATIONS=10
-TIMEOUT=3600  # 1 hour timeout for agent completion
-
-# Thresholds by mode
-declare -A GATE_THRESHOLD=(
-  [mvp]=0.70
-  [standard]=0.75
-  [enterprise]=0.75
-)
-
-declare -A CONSENSUS_THRESHOLD=(
-  [mvp]=0.80
-  [standard]=0.90
-  [enterprise]=0.95
-)
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    --loop3-agents)
-      LOOP3_AGENTS="$2"
-      shift 2
-      ;;
-    --loop2-agents)
-      LOOP2_AGENTS="$2"
-      shift 2
-      ;;
-    --product-owner)
-      PRODUCT_OWNER="$2"
-      shift 2
-      ;;
-    --max-iterations)
-      MAX_ITERATIONS="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$TASK_ID" ] || [ -z "$LOOP3_AGENTS" ] || [ -z "$LOOP2_AGENTS" ] || [ -z "$PRODUCT_OWNER" ]; then
-  echo "Error: Required parameters missing"
-  echo "Usage: $0 --task-id <id> --mode <mode> --loop3-agents <agents> --loop2-agents <agents> --product-owner <agent>"
-  exit 1
-fi
-
-GATE=${GATE_THRESHOLD[$MODE]}
-CONSENSUS=${CONSENSUS_THRESHOLD[$MODE]}
-
-echo "=== CFN Loop Orchestration ==="
-echo "Task ID: $TASK_ID"
-echo "Mode: $MODE (Gate: $GATE, Consensus: $CONSENSUS)"
-echo "Max Iterations: $MAX_ITERATIONS"
-echo ""
-
-# Iteration loop
-for ITERATION in $(seq 1 $MAX_ITERATIONS); do
-  echo "=== Iteration $ITERATION/$MAX_ITERATIONS ==="
-
-  # Step 1: Wait for Loop 3 agents to complete
-  echo "[Loop 3] Waiting for implementers to complete..."
-  IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
-
-  for AGENT in "${AGENTS[@]}"; do
-    DONE_KEY="swarm:${TASK_ID}:${AGENT}:done"
-    echo "  Waiting for $AGENT..."
-
-    # BLPOP with timeout (blocks until agent signals done)
-    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
-
-    if [ -z "$RESULT" ]; then
-      echo "  ❌ ERROR: $AGENT timeout after ${TIMEOUT}s"
-      exit 1
-    fi
-
-    echo "  ✅ $AGENT complete"
-  done
-
-  echo "[Loop 3] All implementers complete!"
-  echo ""
-
-  # Step 2: Collect Loop 3 confidence scores
-  echo "[Loop 3] Collecting confidence scores..."
-  LOOP3_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
-    --task-id "$TASK_ID" \
-    --agent-ids "$LOOP3_AGENTS" | tail -1)
-
-  echo "[Loop 3] Average confidence: $LOOP3_CONSENSUS"
-
-  # Gate check
-  if (( $(echo "$LOOP3_CONSENSUS < $GATE" | bc -l) )); then
-    echo "❌ Gate FAILED ($LOOP3_CONSENSUS < $GATE)"
-    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
-
-    # Wake Loop 3 agents for next iteration
-    IFS=',' read -ra AGENTS <<< "$LOOP3_AGENTS"
-    for AGENT in "${AGENTS[@]}"; do
-      ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-        --task-id "$TASK_ID" \
-        --agent-id "$AGENT" \
-        --reason "gate_failed" \
-        --iteration $((ITERATION + 1)) \
-        --feedback "Improve confidence from $LOOP3_CONSENSUS to >$GATE"
-    done
-
-    continue  # Next iteration
-  fi
-
-  echo "✅ Gate PASSED ($LOOP3_CONSENSUS >= $GATE)"
-  echo ""
-
-  # Step 3: Wait for Loop 2 validators to complete
-  echo "[Loop 2] Waiting for validators to complete..."
-  IFS=',' read -ra VALIDATORS <<< "$LOOP2_AGENTS"
-
-  for VALIDATOR in "${VALIDATORS[@]}"; do
-    DONE_KEY="swarm:${TASK_ID}:${VALIDATOR}:done"
-    echo "  Waiting for $VALIDATOR..."
-
-    RESULT=$(timeout $TIMEOUT redis-cli blpop "$DONE_KEY" 0 2>/dev/null || echo "")
-
-    if [ -z "$RESULT" ]; then
-      echo "  ❌ ERROR: $VALIDATOR timeout after ${TIMEOUT}s"
-      exit 1
-    fi
-
-    echo "  ✅ $VALIDATOR complete"
-  done
-
-  echo "[Loop 2] All validators complete!"
-  echo ""
-
-  # Step 4: Collect Loop 2 consensus scores
-  echo "[Loop 2] Collecting consensus scores..."
-  LOOP2_CONSENSUS=$(./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh collect \
-    --task-id "$TASK_ID" \
-    --agent-ids "$LOOP2_AGENTS" | tail -1)
-
-  echo "[Loop 2] Average consensus: $LOOP2_CONSENSUS"
-
-  # Consensus check
-  if (( $(echo "$LOOP2_CONSENSUS >= $CONSENSUS" | bc -l) )); then
-    echo "✅ CONSENSUS REACHED ($LOOP2_CONSENSUS >= $CONSENSUS)"
-    echo ""
-
-    # Signal Product Owner that consensus is ready
-    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:consensus-ready"
-    redis-cli lpush "$DECISION_KEY" "{\"iteration\": $ITERATION, \"consensus\": $LOOP2_CONSENSUS}" > /dev/null
-
-    # Wait for Product Owner decision
-    echo "[Product Owner] Waiting for GOAP decision..."
-    DECISION_KEY="swarm:${TASK_ID}:${PRODUCT_OWNER}:decision"
-    DECISION=$(timeout $TIMEOUT redis-cli blpop "$DECISION_KEY" 0 2>/dev/null | tail -1)
-
-    if [ -z "$DECISION" ]; then
-      echo "❌ ERROR: Product Owner timeout"
-      exit 1
-    fi
-
-    DECISION_TYPE=$(echo "$DECISION" | jq -r '.decision')
-
-    echo "[Product Owner] Decision: $DECISION_TYPE"
-
-    if [ "$DECISION_TYPE" = "PROCEED" ]; then
-      echo ""
-      echo "🎉 CFN Loop Complete!"
-      echo "Final Consensus: $LOOP2_CONSENSUS (Iteration $ITERATION)"
-
-      # Wake all agents with completion signal
-      IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
-      for AGENT in "${ALL_AGENTS[@]}"; do
-        ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-          --task-id "$TASK_ID" \
-          --agent-id "$AGENT" \
-          --reason "cfn_complete" \
-          --iteration "$ITERATION"
-      done
-
-      exit 0
-    fi
-
-  else
-    echo "⚠️ CONSENSUS NOT REACHED ($LOOP2_CONSENSUS < $CONSENSUS)"
-    echo "Decision: RELAUNCH iteration $((ITERATION + 1))"
-    echo ""
-  fi
-
-  # Relaunch next iteration
-  if [ $ITERATION -eq $MAX_ITERATIONS ]; then
-    echo "❌ Maximum iterations ($MAX_ITERATIONS) reached without consensus"
-    exit 1
-  fi
-
-  # Wake all agents for next iteration
-  echo "[Coordinator] Waking agents for iteration $((ITERATION + 1))..."
-  IFS=',' read -ra ALL_AGENTS <<< "$LOOP3_AGENTS,$LOOP2_AGENTS"
-  for AGENT in "${ALL_AGENTS[@]}"; do
-    ./.claude/skills/cfn-redis-coordination/invoke-waiting-mode.sh wake \
-      --task-id "$TASK_ID" \
-      --agent-id "$AGENT" \
-      --reason "cfn_loop_iteration" \
-      --iteration $((ITERATION + 1)) \
-      --feedback "Improve consensus from $LOOP2_CONSENSUS to >=$CONSENSUS"
-  done
-
-  echo ""
-done
-
-echo "❌ CFN Loop failed after $MAX_ITERATIONS iterations"
-exit 1

package/.claude/skills/cfn-loop-orchestration-v2/lib/validation/validate-deliverables.sh.backup

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-##############################################################################
-# Validate Deliverables - TypeScript Wrapper
-#
-# Checks if deliverable files exist and are accessible.
-#
-# Usage:
-#   ./validate-deliverables.sh --paths file1.js,file2.js [--json]
-#   ./validate-deliverables.sh --file-list paths.txt [--json]
-#
-# Returns JSON with validation results
-# Exit codes:
-#   0 - All deliverables exist
-#   1 - Some deliverables missing
-##############################################################################
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TS_DIST="$SCRIPT_DIR/dist/cli/validate-deliverables.js"
-
-# Check if TypeScript implementation exists
-if [ ! -f "$TS_DIST" ]; then
-  echo "Error: TypeScript implementation not found at: $TS_DIST" >&2
-  echo "Run 'npm run build' in $SCRIPT_DIR" >&2
-  exit 1
-fi
-
-# Check if node is available
-if ! command -v node &>/dev/null; then
-  echo "Error: Node.js is required but not found in PATH" >&2
-  exit 1
-fi
-
-# Execute TypeScript implementation
-exec node "$TS_DIST" "$@"