claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/loop3-output-processing/execute-and-extract.sh

@@ -1,85 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Parse arguments
-AGENT_TYPE=""
-TASK_ID=""
-AGENT_ID=""
-CONTEXT=""
-ITERATION=1
-TIMEOUT=900
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --agent-type) AGENT_TYPE="$2"; shift 2 ;;
-    --task-id) TASK_ID="$2"; shift 2 ;;
-    --agent-id) AGENT_ID="$2"; shift 2 ;;
-    --context) CONTEXT="$2"; shift 2 ;;
-    --iteration) ITERATION="$2"; shift 2 ;;
-    --timeout) TIMEOUT="$2"; shift 2 ;;
-    *) echo "ERROR: Unknown parameter: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Validate required parameters
-if [ -z "$AGENT_TYPE" ] || [ -z "$TASK_ID" ] || [ -z "$AGENT_ID" ] || [ -z "$CONTEXT" ]; then
-  echo "ERROR: Missing required parameters" >&2
-  echo "Usage: $0 --agent-type TYPE --task-id ID --agent-id ID --context CONTEXT [--iteration N] [--timeout SECONDS]" >&2
-  exit 1
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Capture git state before agent runs
-BEFORE_GIT=$(git status --short 2>/dev/null || echo "")
-
-# Spawn agent and capture output
-AGENT_OUTPUT=$(timeout "$TIMEOUT" npx claude-flow-novice agent "$AGENT_TYPE" \
-  --task-id "$TASK_ID" \
-  --agent-id "$AGENT_ID" \
-  --context "$CONTEXT" 2>&1 || true)
-
-# Capture git state after agent runs
-AFTER_GIT=$(git status --short 2>/dev/null || echo "")
-
-# Parse confidence from output
-CONFIDENCE=$("$SCRIPT_DIR/parse-confidence.sh" "$AGENT_OUTPUT")
-
-# Verify deliverables
-DELIVERABLE_CHECK=$("$SCRIPT_DIR/verify-deliverables.sh" \
-  --before "$BEFORE_GIT" \
-  --after "$AFTER_GIT")
-
-FILES_CHANGED=$(echo "$DELIVERABLE_CHECK" | jq -r '.files_changed')
-DELIVERABLES=$(echo "$DELIVERABLE_CHECK" | jq -r '.deliverables')
-
-# If confidence not found or too low, calculate fallback
-if (( $(echo "$CONFIDENCE == 0.0" | bc -l) )) || [ -z "$CONFIDENCE" ]; then
-  CONFIDENCE=$("$SCRIPT_DIR/calculate-confidence.sh" \
-    --files-changed "$FILES_CHANGED" \
-    --deliverables "$DELIVERABLES")
-  CONFIDENCE_SOURCE="calculated"
-elif (( $(echo "$CONFIDENCE > 0.0" | bc -l) )); then
-  CONFIDENCE_SOURCE="explicit"
-else
-  CONFIDENCE_SOURCE="fallback"
-fi
-
-# Build output JSON using jq to ensure proper formatting
-jq -n \
-  --arg agent_id "$AGENT_ID" \
-  --argjson confidence "$CONFIDENCE" \
-  --arg confidence_source "$CONFIDENCE_SOURCE" \
-  --argjson files_changed "$FILES_CHANGED" \
-  --argjson deliverables "$DELIVERABLES" \
-  --arg iteration "$ITERATION" \
-  --arg timestamp "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  '{
-    agent_id: $agent_id,
-    confidence: $confidence,
-    confidence_source: $confidence_source,
-    files_changed: $files_changed,
-    deliverables: $deliverables,
-    iteration: ($iteration | tonumber),
-    timestamp: $timestamp
-  }'

package/.claude/skills/loop3-output-processing/parse-confidence.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-OUTPUT="$1"
-
-# Pattern 1: Explicit confidence (0.0-1.0)
-if CONF=$(echo "$OUTPUT" | grep -oP '[Cc]onfidence[:\s]*([0-9.]+)' | grep -oP '([0-9.]+)' | head -1); then
-  echo "$CONF"
-  exit 0
-fi
-
-# Pattern 2: Percentage (85%)
-if PERCENT=$(echo "$OUTPUT" | grep -oP '([0-9]{1,3})%' | grep -oP '[0-9]+' | head -1); then
-  echo "scale=2; $PERCENT / 100" | bc
-  exit 0
-fi
-
-# Pattern 3: Natural language with score in parentheses
-if CONF=$(echo "$OUTPUT" | grep -oP '\(([0-9.]+)\)' | grep -oP '[0-9.]+' | head -1); then
-  echo "$CONF"
-  exit 0
-fi
-
-# Pattern 4: Score with colon
-if CONF=$(echo "$OUTPUT" | grep -oP '[Ss]core[:\s]*([0-9.]+)' | grep -oP '([0-9.]+)' | head -1); then
-  echo "$CONF"
-  exit 0
-fi
-
-# No confidence found
-echo "0.0"

package/.claude/skills/loop3-output-processing/test-agent-timeout.sh

@@ -1,327 +0,0 @@
-#!/usr/bin/env bash
-##############################################################################
-# Enhanced Test Agent Completion Protocol with Timeout
-# Comprehensive tests for process monitoring and completion detection
-##############################################################################
-set -euo pipefail
-
-# Explicit PATH to ensure all commands are found
-export PATH="/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"
-
-# Fail if any required command is missing
-command -v redis-cli >/dev/null 2>&1 || { echo "❌ redis-cli not found. Please install Redis."; exit 1; }
-
-# Environment-independent script directory with fallback
-SCRIPT_DIR="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)}"
-REDIS_COORDINATION_DIR="${SCRIPT_DIR}/../redis-coordination"
-
-# Safer unique task ID generation
-TASK_ID="test-timeout-$(date +%Y%m%d%H%M%S)-$$-${RANDOM}"
-export TASK_ID
-
-# Test configuration with defaults
-TEST_PASSED=0
-TEST_FAILED=0
-TOTAL_TESTS=4
-TIMEOUT_DURATION="${2:-60}"  # Optional timeout override
-
-# Logging functions with timestamp
-log_info() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO] $*" >&2; }
-log_error() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] $*" >&2; }
-log_test() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] [TEST] $*" >&2; }
-
-# Redis connection with more robust validation
-validate_redis_connection() {
-    log_info "Validating Redis connection..."
-    if ! timeout 5 redis-cli ping >/dev/null 2>&1; then
-        log_error "Redis server not responding. Ensure Redis is running."
-        exit 1
-    fi
-    log_info "Redis connection validated successfully."
-}
-
-# Mock implementation of process monitoring
-mock_monitor_agent_process() {
-    local AGENT_ID="$1"
-    local AGENT_PID="$2"
-    local TASK_ID="$3"
-    local DONE_KEY="$4"
-    local TIMEOUT="${5:-60}"  # Default 60s timeout
-
-    log_info "Mocking process monitor for Agent $AGENT_ID (PID: $AGENT_PID)"
-
-    (
-        sleep "$TIMEOUT"
-        if kill -0 "$AGENT_PID" 2>/dev/null; then
-            log_error "Agent $AGENT_ID exceeded timeout. Killing process."
-            kill -9 "$AGENT_PID" 2>/dev/null
-            redis-cli LPUSH "$DONE_KEY" "auto-completed-timeout" >/dev/null
-        fi
-    ) &
-}
-
-# Mock heartbeat mechanism
-mock_send_heartbeat() {
-    local TASK_ID="$1"
-    local AGENT_ID="$2"
-    local INTERVAL="${3:-5}"
-
-    log_info "Starting mock heartbeat for Task $TASK_ID, Agent $AGENT_ID"
-
-    # Simulate periodic heartbeat
-    while true; do
-        log_info "Sending heartbeat for $AGENT_ID"
-        redis-cli SETEX "swarm:${TASK_ID}:${AGENT_ID}:heartbeat" "$((INTERVAL * 2))" "active" >/dev/null 2>&1
-        sleep "$INTERVAL"
-    done
-}
-
-# Create mock agent scripts
-create_mock_agent() {
-    local behavior="$1"
-    local script_path="/tmp/mock-agent-${behavior}-${TASK_ID}.sh"
-
-    log_info "Creating mock agent script with behavior: $behavior"
-
-    case "$behavior" in
-        success)
-            cat > "$script_path" <<'AGENT_EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-TASK_ID="$1"
-AGENT_ID="$2"
-log_test() { echo "[Mock Agent Test] $*" >&2; }
-log_test "Starting work..."
-sleep 2
-log_test "Work complete - signaling done"
-redis-cli LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete" >/dev/null
-exit 0
-AGENT_EOF
-            ;;
-        failure)
-            cat > "$script_path" <<'AGENT_EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-TASK_ID="$1"
-AGENT_ID="$2"
-log_test() { echo "[Mock Agent Test] $*" >&2; }
-log_test "Starting work..."
-sleep 2
-log_test "Work failed - exiting with error"
-exit 1
-AGENT_EOF
-            ;;
-        stuck)
-            cat > "$script_path" <<'AGENT_EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-TASK_ID="$1"
-AGENT_ID="$2"
-log_test() { echo "[Mock Agent Test] $*" >&2; }
-log_test "Starting work..."
-log_test "Agent stuck in infinite loop"
-while true; do
-  sleep 10
-done
-AGENT_EOF
-            ;;
-        crash)
-            cat > "$script_path" <<'AGENT_EOF'
-#!/usr/bin/env bash
-set -euo pipefail
-TASK_ID="$1"
-AGENT_ID="$2"
-log_test() { echo "[Mock Agent Test] $*" >&2; }
-log_test "Starting work..."
-sleep 1
-log_test "Agent crashed unexpectedly"
-kill -9 $$
-AGENT_EOF
-            ;;
-        *)
-            log_error "Invalid agent behavior: $behavior"
-            return 1
-            ;;
-    esac
-
-    chmod +x "$script_path"
-    echo "$script_path"
-}
-
-# Track test result
-track_test_result() {
-    local status="$1"
-    if [ "$status" -eq 0 ]; then
-        log_test "✅ PASS"
-        ((TEST_PASSED++))
-    else
-        log_test "❌ FAIL"
-        ((TEST_FAILED++))
-    fi
-}
-
-##############################################################################
-# Test Case 1: Normal Agent Completion
-##############################################################################
-test_agent_success() {
-    log_test "Test 1: Agent Completes Successfully"
-    local AGENT_ID="agent-success-1"
-    local DONE_KEY="swarm:${TASK_ID}:${AGENT_ID}:done"
-
-    # Create and run mock agent
-    local AGENT_SCRIPT
-    AGENT_SCRIPT=$(create_mock_agent "success")
-    bash "$AGENT_SCRIPT" "$TASK_ID" "$AGENT_ID" &
-    local AGENT_PID=$!
-    log_info "Started success agent (PID: $AGENT_PID)"
-
-    # Monitor agent process
-    mock_monitor_agent_process "$AGENT_ID" "$AGENT_PID" "$TASK_ID" "$DONE_KEY" 10
-
-    # Wait for completion
-    local RESULT
-    RESULT=$(timeout 5 redis-cli BLPOP "$DONE_KEY" 5 2>&1 || echo "timeout")
-    log_info "Success Test Result: $RESULT"
-
-    if [[ "$RESULT" == *"complete"* ]]; then
-        track_test_result 0
-    else
-        track_test_result 1
-    fi
-}
-
-##############################################################################
-# Test Case 2: Agent Exits with Error
-##############################################################################
-test_agent_failure() {
-    log_test "Test 2: Agent Exits with Error"
-    local AGENT_ID="agent-failure-1"
-    local DONE_KEY="swarm:${TASK_ID}:${AGENT_ID}:done"
-
-    # Create and run mock agent
-    local AGENT_SCRIPT
-    AGENT_SCRIPT=$(create_mock_agent "failure")
-    bash "$AGENT_SCRIPT" "$TASK_ID" "$AGENT_ID" &
-    local AGENT_PID=$!
-    log_info "Started failure agent (PID: $AGENT_PID)"
-
-    # Monitor agent process
-    mock_monitor_agent_process "$AGENT_ID" "$AGENT_PID" "$TASK_ID" "$DONE_KEY" 10
-
-    # Wait and check result
-    sleep 3
-    local RESULT
-    RESULT=$(redis-cli LPOP "$DONE_KEY" 2>&1)
-    log_info "Failure Test Result: ${RESULT:-empty}"
-
-    if [[ -z "$RESULT" ]]; then
-        track_test_result 0
-    else
-        track_test_result 1
-    fi
-}
-
-##############################################################################
-# Test Case 3: Agent Stuck Without Heartbeat
-##############################################################################
-test_agent_stuck() {
-    log_test "Test 3: Agent Stuck Without Heartbeat"
-    local AGENT_ID="agent-stuck-1"
-    local DONE_KEY="swarm:${TASK_ID}:${AGENT_ID}:done"
-
-    # Create and run mock agent
-    local AGENT_SCRIPT
-    AGENT_SCRIPT=$(create_mock_agent "stuck")
-    bash "$AGENT_SCRIPT" "$TASK_ID" "$AGENT_ID" &
-    local AGENT_PID=$!
-    log_info "Started stuck agent (PID: $AGENT_PID)"
-
-    # Monitor agent process with short timeout
-    mock_monitor_agent_process "$AGENT_ID" "$AGENT_PID" "$TASK_ID" "$DONE_KEY" 5
-
-    # Wait and check if process was killed
-    sleep 6
-    if ! kill -0 "$AGENT_PID" 2>/dev/null; then
-        track_test_result 0
-    else
-        log_error "Stuck process not terminated, forcefully killing"
-        kill -9 "$AGENT_PID" 2>/dev/null || true
-        track_test_result 1
-    fi
-}
-
-##############################################################################
-# Test Case 4: Agent with Continuous Heartbeat
-##############################################################################
-test_agent_with_heartbeat() {
-    log_test "Test 4: Agent with Continuous Heartbeat"
-    local AGENT_ID="agent-heartbeat-1"
-
-    # Start mock heartbeat
-    mock_send_heartbeat "$TASK_ID" "$AGENT_ID" 2 &
-    local HEARTBEAT_PID=$!
-    log_info "Started heartbeat process (PID: $HEARTBEAT_PID)"
-
-    # Wait and check heartbeat
-    sleep 5
-    local HEARTBEAT_EXISTS
-    HEARTBEAT_EXISTS=$(redis-cli EXISTS "swarm:${TASK_ID}:${AGENT_ID}:heartbeat" 2>&1)
-    log_info "Heartbeat Exists Result: $HEARTBEAT_EXISTS"
-
-    if [ "$HEARTBEAT_EXISTS" -eq 1 ]; then
-        track_test_result 0
-    else
-        track_test_result 1
-    fi
-
-    # Kill heartbeat process
-    kill -9 "$HEARTBEAT_PID" 2>/dev/null
-}
-
-##############################################################################
-# Test Execution
-##############################################################################
-main() {
-    log_info "=== Agent Timeout Protocol Test Suite ==="
-    log_info "Task ID: $TASK_ID"
-
-    # Validate prerequisites
-    validate_redis_connection
-
-    # Run tests with error handling
-    log_info "Running ${TOTAL_TESTS} tests..."
-
-    (test_agent_success) || true
-    (test_agent_failure) || true
-    (test_agent_stuck) || true
-    (test_agent_with_heartbeat) || true
-
-    # Report results
-    log_info "=== Test Summary ==="
-    log_info "Passed: $TEST_PASSED/$TOTAL_TESTS"
-    log_info "Failed: $TEST_FAILED/$TOTAL_TESTS"
-
-    # Cleanup Redis keys
-    redis-cli --scan --pattern "swarm:${TASK_ID}:*" | xargs -r redis-cli DEL >/dev/null 2>&1 || true
-
-    # Exit with appropriate status
-    if [ $TEST_FAILED -eq 0 ]; then
-        log_info "✅ ALL TESTS PASSED (Confidence: 0.95)"
-        exit 0
-    else
-        log_error "❌ SOME TESTS FAILED"
-        exit 1
-    fi
-}
-
-# Add explicit error tracing for debugging
-trap 'log_error "Error on line $LINENO. Command: $BASH_COMMAND"' ERR
-
-# Execute main function with optional error handling
-if main "$@"; then
-    log_info "✅ Test suite completed successfully"
-    exit 0
-else
-    log_error "❌ Test suite encountered issues"
-    exit 1
-fi

package/.claude/skills/loop3-output-processing/test-loop3-processing.sh

@@ -1,155 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PASSED=0
-FAILED=0
-
-# Colors for output
-GREEN='\033[0;32m'
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-echo "================================"
-echo "Loop 3 Output Processing Tests"
-echo "================================"
-
-# Test 1: Parse explicit confidence
-echo -e "\n${YELLOW}Test 1: Parse Explicit Confidence${NC}"
-OUTPUT="Implementation complete. Confidence: 0.85"
-RESULT=$("$SCRIPT_DIR/parse-confidence.sh" "$OUTPUT")
-if [ "$RESULT" = "0.85" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Extracted: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.85, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 2: Parse percentage format
-echo -e "\n${YELLOW}Test 2: Parse Percentage Format${NC}"
-OUTPUT="I'm 92% confident in this implementation"
-RESULT=$("$SCRIPT_DIR/parse-confidence.sh" "$OUTPUT")
-if [ "$RESULT" = ".92" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Extracted: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected .92, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 3: Parse natural language with score
-echo -e "\n${YELLOW}Test 3: Parse Natural Language with Score${NC}"
-OUTPUT="Very confident about this (0.90)"
-RESULT=$("$SCRIPT_DIR/parse-confidence.sh" "$OUTPUT")
-if [ "$RESULT" = "0.90" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Extracted: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.90, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 4: No confidence found (fallback)
-echo -e "\n${YELLOW}Test 4: No Confidence Found (Fallback)${NC}"
-OUTPUT="I implemented the feature and it works great!"
-RESULT=$("$SCRIPT_DIR/parse-confidence.sh" "$OUTPUT")
-if [ "$RESULT" = "0.0" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Fallback: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.0, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 5: Verify deliverables - no changes
-echo -e "\n${YELLOW}Test 5: Verify Deliverables - No Changes${NC}"
-BEFORE="M  package.json"
-AFTER="M  package.json"
-RESULT=$("$SCRIPT_DIR/verify-deliverables.sh" --before "$BEFORE" --after "$AFTER")
-FILES_CHANGED=$(echo "$RESULT" | jq -r '.files_changed')
-if [ "$FILES_CHANGED" = "0" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - No new files: $FILES_CHANGED"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0, got: $FILES_CHANGED"
-  ((FAILED++))
-fi
-
-# Test 6: Verify deliverables - new files
-echo -e "\n${YELLOW}Test 6: Verify Deliverables - New Files${NC}"
-BEFORE="M  package.json"
-AFTER="M  package.json
-A  src/auth/login.ts
-A  tests/auth.test.ts"
-RESULT=$("$SCRIPT_DIR/verify-deliverables.sh" --before "$BEFORE" --after "$AFTER")
-FILES_CHANGED=$(echo "$RESULT" | jq -r '.files_changed')
-if [ "$FILES_CHANGED" = "2" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - New files detected: $FILES_CHANGED"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 2, got: $FILES_CHANGED"
-  ((FAILED++))
-fi
-
-# Test 7: Calculate confidence - no files
-echo -e "\n${YELLOW}Test 7: Calculate Confidence - No Files${NC}"
-RESULT=$("$SCRIPT_DIR/calculate-confidence.sh" --files-changed 0 --deliverables "[]")
-if [ "$RESULT" = "0.0" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Calculated: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.0, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 8: Calculate confidence - minimal changes
-echo -e "\n${YELLOW}Test 8: Calculate Confidence - Minimal Changes${NC}"
-RESULT=$("$SCRIPT_DIR/calculate-confidence.sh" --files-changed 2 --deliverables '["file1", "file2"]')
-if [ "$RESULT" = "0.50" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Calculated: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.50, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 9: Calculate confidence - moderate changes
-echo -e "\n${YELLOW}Test 9: Calculate Confidence - Moderate Changes${NC}"
-RESULT=$("$SCRIPT_DIR/calculate-confidence.sh" --files-changed 4 --deliverables '["f1","f2","f3","f4"]')
-if [ "$RESULT" = "0.75" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Calculated: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.75, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Test 10: Calculate confidence - significant changes
-echo -e "\n${YELLOW}Test 10: Calculate Confidence - Significant Changes${NC}"
-RESULT=$("$SCRIPT_DIR/calculate-confidence.sh" --files-changed 8 --deliverables '["f1","f2","f3","f4","f5","f6","f7","f8"]')
-if [ "$RESULT" = "0.85" ]; then
-  echo -e "${GREEN}✓ PASS${NC} - Calculated: $RESULT"
-  ((PASSED++))
-else
-  echo -e "${RED}✗ FAIL${NC} - Expected 0.85, got: $RESULT"
-  ((FAILED++))
-fi
-
-# Summary
-echo ""
-echo "================================"
-echo "Test Results"
-echo "================================"
-echo -e "${GREEN}Passed: $PASSED${NC}"
-echo -e "${RED}Failed: $FAILED${NC}"
-echo ""
-
-if [ $FAILED -eq 0 ]; then
-  echo -e "${GREEN}✓ All tests passed!${NC}"
-  exit 0
-else
-  echo -e "${RED}✗ Some tests failed${NC}"
-  exit 1
-fi

package/.claude/skills/loop3-output-processing/verify-deliverables.sh

@@ -1,42 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-BEFORE=""
-AFTER=""
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --before) BEFORE="$2"; shift 2 ;;
-    --after) AFTER="$2"; shift 2 ;;
-    *) echo "ERROR: Unknown parameter: $1" >&2; exit 1 ;;
-  esac
-done
-
-# Find new/modified files (compare before and after git status)
-CHANGED_FILES=$(comm -13 <(echo "$BEFORE" | sort) <(echo "$AFTER" | sort) 2>/dev/null || true)
-FILE_COUNT=$(echo "$CHANGED_FILES" | grep -c '^' 2>/dev/null || echo "0")
-
-# Build deliverables JSON array
-DELIVERABLES="["
-FIRST=true
-while IFS= read -r line; do
-  if [ -n "$line" ]; then
-    if [ "$FIRST" = true ]; then
-      FIRST=false
-    else
-      DELIVERABLES+=","
-    fi
-    # Escape quotes in filename
-    ESCAPED_LINE=$(echo "$line" | sed 's/"/\\"/g')
-    DELIVERABLES+="\"$ESCAPED_LINE\""
-  fi
-done <<< "$CHANGED_FILES"
-DELIVERABLES+="]"
-
-# Output JSON
-cat <<EOF
-{
-  "files_changed": $FILE_COUNT,
-  "deliverables": $DELIVERABLES
-}
-EOF

package/.claude/skills/pattern-extraction/SKILL.md

@@ -1,30 +0,0 @@
-# Pattern Extraction Skill
-
-## Purpose
-Extract reusable patterns from CFN Loop retrospective data to improve future sprint execution.
-
-## Key Responsibilities
-- Analyze feedback themes
-- Identify recurring patterns
-- Calculate pattern frequency
-- Generate pattern recommendations
-
-## Pattern Identification Algorithm
-1. Analyze feedback themes across multiple sprints
-2. Use statistical methods to identify significant patterns
-3. Create pattern confidence score based on:
-   - Frequency of occurrence
-   - Impact on sprint success
-   - Reliability of evidence
-
-## Pattern Types
-- Agent Synergy Patterns
-- Feedback Resolution Patterns
-- Task Type Optimization Patterns
-- Complexity Estimation Patterns
-
-## Implementation Guidelines
-- Maintain pattern database
-- Update patterns incrementally
-- Use machine learning for pattern refinement
-- Ensure explainability of patterns