claude-flow-novice 2.15.0 → 2.15.2

package/claude-assets/cfn-extras/skills/advanced-features/cfn-task-mode-safety/mode-detection.sh

@@ -0,0 +1,326 @@
+#!/bin/bash
+# CFN Task Mode Safety - Mode Detection and Enforcement
+# Part of ANTI-023 Memory Leak Protection System
+
+set -e
+
+# Mode Detection Script for CFN Loop Safety
+
+CFN_MODE_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Mode Detection Function
+detect_execution_mode() {
+    local mode=""
+
+    # 1. Environment variable check
+    if [[ -n "${CFN_MODE:-}" ]]; then
+        mode="$CFN_MODE"
+        echo "🔍 Mode detected from CFN_MODE: $mode" >&2
+        echo "$mode"  # CRITICAL: Echo detected value for regression testing
+        return 0
+    fi
+
+    # 2. Task ID/Agent ID presence check (CLI mode indicators)
+    if [[ -n "${TASK_ID:-}" && -n "${AGENT_ID:-}" ]]; then
+        mode="cli"
+        echo "🔍 Mode detected from TASK_ID/AGENT_ID: $mode" >&2
+        echo "$mode"  # CRITICAL: Echo detected value for regression testing
+        return 0
+    fi
+
+    # 3. Process inspection (check if spawned by Task() tool)
+    if [[ "${PPID:-}" -gt 0 ]]; then
+        local parent_cmd=$(ps -o comm= -p "$PPID" 2>/dev/null || echo "unknown")
+        if [[ "$parent_cmd" == *"claude"* || "$parent_cmd" == *"Task"* ]]; then
+            mode="task"
+            echo "🔍 Mode detected from parent process: $mode" >&2
+            echo "$mode"  # CRITICAL: Echo detected value for regression testing
+            return 0
+        fi
+    fi
+
+    # 4. Check for script calling context (CLI mode indicators)
+    if [[ -n "${__CFN_CLI_SPAWN:-}" ]]; then
+        mode="cli"
+        echo "🔍 Mode detected from CLI spawn marker: $mode" >&2
+        echo "$mode"  # CRITICAL: Echo detected value for regression testing
+        return 0
+    fi
+
+    # 5. Fallback to task mode for safety
+    mode="task"
+    echo "🔍 Defaulting to safe mode: $mode" >&2
+    echo "$mode"  # CRITICAL: Echo detected value for regression testing
+    return 0
+}
+
+# Is Task Mode Function
+is_task_mode() {
+    local mode=$(detect_execution_mode)
+    [[ "$mode" == "task" ]]
+}
+
+# Is CLI Mode Function
+is_cli_mode() {
+    local mode=$(detect_execution_mode)
+    [[ "$mode" == "cli" ]]
+}
+
+# Mode Compliance Enforcement
+enforce_mode_compliance() {
+    local operation="$1"
+
+    if is_task_mode; then
+        echo "❌ TASK MODE DETECTED - Redis coordination forbidden" >&2
+        echo "🚨 ANTI-023: '$operation' requires CLI mode, detected Task mode" >&2
+        echo "💡 Task mode agents should use direct JSON output" >&2
+        echo "💡 Switch to CLI mode: use /cfn-loop-cli instead of /cfn-loop-task" >&2
+        return 1
+    fi
+
+    if is_cli_mode; then
+        echo "✅ CLI mode - '$operation' allowed" >&2
+        return 0
+    fi
+
+    # Unknown mode, default to safe (Task mode)
+    echo "❓ Unknown mode - defaulting to Task mode safety" >&2
+    return 1
+}
+
+# Safe Redis Operation Wrapper
+redis_cli_safe() {
+    if ! enforce_mode_compliance "redis_cli"; then
+        return 1
+    fi
+
+    # CLI mode - Execute Redis command
+    redis-cli "$@"
+}
+
+# Safe Coordination Operation Wrapper
+cfn_coordination_safe() {
+    local operation="$1"
+    shift
+
+    if ! enforce_mode_compliance "coordination"; then
+        # Task mode fallback - use file-based signaling
+        cfn_task_fallback "$operation" "$@"
+        return $?
+    fi
+
+    # CLI mode - Use Redis coordination
+    case "$operation" in
+        "signal-complete")
+            local task_id="$1"
+            local agent_id="$2"
+            redis_cli_safe LPUSH "swarm:${task_id}:${agent_id}:done" "complete"
+            ;;
+        "store-confidence")
+            local task_id="$1"
+            local agent_id="$2"
+            local confidence="$3"
+            redis_cli_safe SET "swarm:${task_id}:${agent_id}:confidence" "$confidence" EX 3600
+            ;;
+        "store-result")
+            local task_id="$1"
+            local agent_id="$2"
+            local result="$3"
+            redis_cli_safe HSET "swarm:${task_id}:${agent_id}:result" \
+                "confidence" "${result:-0.0}" \
+                "timestamp" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+            ;;
+        *)
+            echo "❌ Unknown coordination operation: $operation" >&2
+            return 1
+            ;;
+    esac
+}
+
+# Task Mode Fallback Implementation
+cfn_task_fallback() {
+    local operation="$1"
+    shift
+
+    local task_id="${TASK_ID:-unknown}"
+    local agent_id="${AGENT_ID:-unknown}"
+    local timestamp="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+    mkdir -p "./.claude/task-signals"
+
+    case "$operation" in
+        "signal-complete")
+            local signal_file="./.claude/task-signals/${task_id}_${agent_id}_complete.json"
+            cat > "$signal_file" <<EOF
+{
+  "signal": "complete",
+  "task_id": "$task_id",
+  "agent_id": "$agent_id",
+  "timestamp": "$timestamp",
+  "mode": "task"
+}
+EOF
+            echo "📝 Task mode completion signal saved: $signal_file" >&2
+            ;;
+        "store-confidence")
+            local confidence="$1"
+            local confidence_file="./.claude/task-signals/${task_id}_${agent_id}_confidence.json"
+            cat > "$confidence_file" <<EOF
+{
+  "signal": "confidence",
+  "task_id": "$task_id",
+  "agent_id": "$agent_id",
+  "confidence": $confidence,
+  "timestamp": "$timestamp",
+  "mode": "task"
+}
+EOF
+            echo "📝 Task mode confidence saved: $confidence_file" >&2
+            ;;
+        *)
+            echo "❌ Unknown fallback operation: $operation" >&2
+            return 1
+            ;;
+    esac
+}
+
+# Task Mode Completion Protocol
+task_mode_complete() {
+    local confidence="$1"
+    local status="${2:-COMPLETE}"
+    local summary="${3:-Work completed}"
+    shift 3 || true
+    local deliverables=("$@")
+
+    # Validate confidence range
+    if ! awk -v conf="$confidence" 'BEGIN { if (conf < 0 || conf > 1) exit 1 }'; then
+        echo "❌ Invalid confidence value: $confidence (must be 0.0-1.0)" >&2
+        exit 1
+    fi
+
+    # Generate JSON response
+    local json_output="{"
+    json_output+='"confidence": '"$confidence"','
+    json_output+='"status": "'"$status"'",'
+    json_output+='"summary": "'"$summary"'",'
+
+    if [[ ${#deliverables[@]} -gt 0 ]]; then
+        json_output+='"deliverables": ['
+        local first=true
+        for deliverable in "${deliverables[@]}"; do
+            if [[ "$first" == true ]]; then
+                first=false
+            else
+                json_output+=","
+            fi
+            json_output+="\"$deliverable\""
+        done
+        json_output+="],"
+    fi
+
+    json_output+='"timestamp": "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'",'
+    json_output+'"mode": "task"'
+    json_output+="}"
+
+    # Output directly to stdout for Main Chat
+    echo "$json_output"
+}
+
+# Task Mode Audit Logging
+task_mode_audit() {
+    local event="$1"
+    local task_id="${TASK_ID:-unknown}"
+    local agent_id="${AGENT_ID:-unknown}"
+    local data="$2"
+
+    local audit_file="./.claude/audit/task-mode/${task_id}_${agent_id}_$(date +%Y%m%d_%H%M%S).json"
+    mkdir -p "$(dirname "$audit_file")"
+
+    cat > "$audit_file" <<EOF
+{
+  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "event": "$event",
+  "task_id": "$task_id",
+  "agent_id": "$agent_id",
+  "data": $data,
+  "mode": "task"
+}
+EOF
+
+    echo "📝 Task mode audit logged: $audit_file" >&2
+}
+
+# Show Usage
+show_usage() {
+    cat <<'EOF'
+CFN Task Mode Safety - Mode Detection and Enforcement
+
+USAGE:
+    source "$(dirname "${BASH_SOURCE[0]}")/mode-detection.sh"
+
+    # Mode Detection
+    detect_execution_mode          # Detect current execution mode
+    is_task_mode                  # Check if running in Task mode
+    is_cli_mode                   # Check if running in CLI mode
+
+    # Enforcement
+    enforce_mode_compliance "operation"  # Enforce mode compliance
+
+    # Safe Operations
+    redis_cli_safe "command" [args...]   # Safe Redis CLI wrapper
+    cfn_coordination_safe "operation" [args...]  # Safe coordination
+
+    # Task Mode Specific
+    task_mode_complete <confidence> <status> <summary> [deliverables...]
+    task_mode_audit <event> <json_data>
+
+EXAMPLES:
+    # Check mode compliance before Redis operations
+    if is_cli_mode; then
+        redis_cli_safe LPUSH "swarm:${TASK_ID}:${AGENT_ID}:done" "complete"
+    else
+        task_mode_complete 0.85 "COMPLETE" "Work done" "file1.js" "file2.js"
+    fi
+
+    # Safe coordination usage
+    cfn_coordination_safe "signal-complete" "$TASK_ID" "$AGENT_ID"
+    cfn_coordination_safe "store-confidence" "$TASK_ID" "$AGENT_ID" 0.85
+
+EOF
+}
+
+# Main execution block
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    if [[ "$1" == "--help" || "$1" == "-h" ]]; then
+        show_usage
+        exit 0
+    fi
+
+    # Execute single operation if provided
+    if [[ $# -gt 0 ]]; then
+        case "$1" in
+            "detect")
+                detect_execution_mode
+                ;;
+            "is-task")
+                is_task_mode; exit $?
+                ;;
+            "is-cli")
+                is_cli_mode; exit $?
+                ;;
+            "compliance")
+                enforce_mode_compliance "$2"
+                ;;
+            *)
+                echo "Unknown operation: $1" >&2
+                echo "Use --help for usage information" >&2
+                exit 1
+                ;;
+        esac
+    else
+        echo "CFN Task Mode Safety System" >&2
+        echo "Mode: $(detect_execution_mode)" >&2
+        echo "Task Mode: $(is_task_mode && echo "YES" || echo "NO")" >&2
+        echo "CLI Mode: $(is_cli_mode && echo "YES" || echo "NO")" >&2
+    fi
+fi

package/claude-assets/cfn-extras/skills/advanced-features/cfn-task-mode-sanitize/task-mode-env-sanitizer.sh

@@ -0,0 +1,267 @@
+#!/usr/bin/env bash
+
+##############################################################################
+# CFN Task Mode Environment Sanitizer
+# Prevents memory leaks and environment contamination in CFN Loop execution
+#
+# Usage:
+#   source task-mode-env-sanitizer.sh
+#   sanitize_task_mode_environment <mode>
+#
+# Modes:
+#   cli - CLI mode execution (production)
+#   task - Task mode execution (debugging)
+##############################################################################
+
+set -euo pipefail
+
+# Global state tracking
+declare -A CFN_SANITIZER_STATE
+CFN_SANITIZER_STATE["initialized"]=false
+CFN_SANITIZER_STATE["mode"]=""
+CFN_SANITIZER_STATE["start_time"]=$(date +%s)
+
+# Memory leak prevention thresholds
+readonly MAX_AGENT_PROCESSES=50
+readonly MAX_MEMORY_MB=4096
+readonly MAX_RUNTIME_SECONDS=3600  # 1 hour
+
+##############################################################################
+# Core Sanitization Functions
+##############################################################################
+
+sanitize_task_mode_environment() {
+    local mode="${1:-task}"
+
+    # Initialize sanitizer state
+    CFN_SANITIZER_STATE["mode"]="$mode"
+    CFN_SANITIZER_STATE["initialized"]=true
+
+    echo "🧹 CFN Environment Sanitizer v1.0.0" >&2
+    echo "   Mode: $mode" >&2
+    echo "   PID: $$" >&2
+    echo "   Start: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >&2
+
+    # Apply mode-specific sanitization
+    case "$mode" in
+        "cli")
+            sanitize_cli_environment
+            ;;
+        "task")
+            sanitize_task_environment
+            ;;
+        *)
+            echo "⚠️ Unknown mode: $mode, applying default sanitization" >&2
+            sanitize_default_environment
+            ;;
+    esac
+
+    # Setup monitoring and cleanup hooks
+    setup_environment_monitoring
+    setup_cleanup_hooks
+
+    echo "✅ Environment sanitization complete" >&2
+}
+
+sanitize_cli_environment() {
+    echo "   Applying CLI mode sanitization..." >&2
+
+    # Clear any previous agent state
+    unset AGENT_ID 2>/dev/null || true
+    unset TASK_ID 2>/dev/null || true
+    unset SWARM_ID 2>/dev/null || true
+
+    # Optimize for production CLI execution
+    export CFN_MODE="cli"
+    export CFN_SANITIZER_ACTIVE=true
+
+    # NOTE: DO NOT set ulimit -u as it causes fork failures
+    # The MAX_AGENT_PROCESSES constant is for monitoring only, not for ulimit
+    # Setting ulimit -u to a low value (50) when 200+ processes exist causes all forks to fail
+    # Instead, we monitor process count and warn if exceeded
+
+    # Set conservative memory limit only
+    ulimit -v $((MAX_MEMORY_MB * 1024)) 2>/dev/null || true
+
+    # Disable debug features in production
+    export CFN_DEBUG=false
+    export CFN_VERBOSE=false
+}
+
+sanitize_task_environment() {
+    echo "   Applying Task mode sanitization..." >&2
+
+    # Task mode allows more debugging
+    export CFN_MODE="task"
+    export CFN_SANITIZER_ACTIVE=true
+
+    # More permissive limits for debugging
+    # NOTE: DO NOT set ulimit -u (see CLI mode comment above)
+    ulimit -v $((MAX_MEMORY_MB * 1024 * 2)) 2>/dev/null || true
+
+    # Enable debug features for task mode
+    export CFN_DEBUG=${CFN_DEBUG:-true}
+    export CFN_VERBOSE=${CFN_VERBOSE:-true}
+}
+
+sanitize_default_environment() {
+    echo "   Applying default sanitization..." >&2
+
+    # Basic sanitization for unknown modes
+    export CFN_MODE="unknown"
+    export CFN_SANITIZER_ACTIVE=true
+
+    # Conservative limits
+    # NOTE: DO NOT set ulimit -u (see CLI mode comment above)
+}
+
+##############################################################################
+# Environment Monitoring
+##############################################################################
+
+setup_environment_monitoring() {
+    # Start background monitoring if available
+    if command -v timeout >/dev/null 2>&1; then
+        (
+            sleep $MAX_RUNTIME_SECONDS
+            if [[ "${CFN_SANITIZER_STATE[initialized]}" == "true" ]]; then
+                echo "⚠️ CFN Environment timeout reached, forcing cleanup" >&2
+                force_environment_cleanup
+            fi
+        ) &
+        echo "   Started runtime monitoring (${MAX_RUNTIME_SECONDS}s)" >&2
+    fi
+}
+
+setup_cleanup_hooks() {
+    # Setup cleanup trap for graceful shutdown
+    trap 'environment_cleanup_on_exit' EXIT
+    trap 'environment_cleanup_on_signal INT' INT
+    trap 'environment_cleanup_on_signal TERM' TERM
+    trap 'environment_cleanup_on_signal HUP' HUP
+}
+
+environment_cleanup_on_exit() {
+    echo "🧹 CFN Environment cleanup on exit" >&2
+
+    # Calculate runtime
+    local end_time=$(date +%s)
+    local runtime=$((end_time - CFN_SANITIZER_STATE["start_time"]))
+    echo "   Runtime: ${runtime}s" >&2
+
+    # Mode-specific cleanup
+    case "${CFN_SANITIZER_STATE[mode]}" in
+        "cli")
+            cleanup_cli_environment
+            ;;
+        "task")
+            cleanup_task_environment
+            ;;
+    esac
+
+    # Clear sanitizer state
+    CFN_SANITIZER_STATE["initialized"]=false
+    echo "✅ Environment cleanup complete" >&2
+}
+
+environment_cleanup_on_signal() {
+    local signal="$1"
+    echo "🧹 CFN Environment cleanup on signal: $signal" >&2
+    environment_cleanup_on_exit
+    exit 130
+}
+
+cleanup_cli_environment() {
+    echo "   CLI mode cleanup..." >&2
+
+    # Clean up any lingering agent processes (using /proc to avoid fork)
+    # This approach reads /proc directly instead of calling external pgrep command
+    # to prevent kernel fork rate limiting in nested process chains
+    local agent_pids=""
+    for pid in /proc/[0-9]*/; do
+        [[ -e "$pid/cmdline" ]] || continue
+        if grep -q "claude-flow-novice.*agent" "$pid/cmdline" 2>/dev/null; then
+            local pid_num=$(basename "$pid")
+            agent_pids="$agent_pids $pid_num"
+        fi
+    done
+
+    if [[ -n "$agent_pids" ]]; then
+        echo "   Warning: Found agent processes:$agent_pids" >&2
+    fi
+}
+
+cleanup_task_environment() {
+    echo "   Task mode cleanup..." >&2
+    # Task mode cleanup - more permissive
+}
+
+force_environment_cleanup() {
+    echo "🚨 Force cleanup triggered!" >&2
+
+    # Kill any remaining processes in this process group
+    if [[ -n "${CFN_PROCESS_GROUP:-}" ]]; then
+        kill -TERM -$CFN_PROCESS_GROUP 2>/dev/null || true
+        sleep 2
+        kill -KILL -$CFN_PROCESS_GROUP 2>/dev/null || true
+    fi
+
+    # Force exit
+    exit 1
+}
+
+##############################################################################
+# Utility Functions
+##############################################################################
+
+check_environment_health() {
+    local mode="${1:-${CFN_SANITIZER_STATE[mode]}}"
+
+    if [[ "${CFN_SANITIZER_STATE[initialized]}" != "true" ]]; then
+        echo "❌ Environment sanitizer not initialized" >&2
+        return 1
+    fi
+
+    # Check memory usage
+    if command -v ps >/dev/null 2>&1; then
+        local memory_mb=$(ps -o rss= -p $$ 2>/dev/null | awk '{print $1/1024}' || echo "0")
+        if (( $(echo "$memory_mb > $MAX_MEMORY_MB" | bc -l 2>/dev/null || echo "0") )); then
+            echo "⚠️ High memory usage: ${memory_mb}MB" >&2
+        fi
+    fi
+
+    # Check process count
+    if command -v ps >/dev/null 2>&1; then
+        local process_count=$(ps -eo pid=,ppid= | grep -c "^[[:space:]]*$$[[:space:]]" || echo "0")
+        if (( process_count > MAX_AGENT_PROCESSES )); then
+            echo "⚠️ High process count: $process_count" >&2
+        fi
+    fi
+
+    echo "✅ Environment health check passed" >&2
+    return 0
+}
+
+get_sanitizer_info() {
+    echo "CFN Environment Sanitizer Info:"
+    echo "  Initialized: ${CFN_SANITIZER_STATE[initialized]}"
+    echo "  Mode: ${CFN_SANITIZER_STATE[mode]}"
+    echo "  Start Time: ${CFN_SANITIZER_STATE[start_time]}"
+    echo "  PID: $$"
+    echo "  Runtime: $(($(date +%s) - CFN_SANITIZER_STATE[start_time]))s"
+}
+
+##############################################################################
+# Auto-initialization for safety
+##############################################################################
+
+# If script is sourced (not executed), make sanitizer available
+if [[ "${BASH_SOURCE[0]}" != "${0}" ]]; then
+    echo "🔧 CFN Environment Sanitizer loaded" >&2
+    echo "   Use: sanitize_task_mode_environment <mode>" >&2
+fi
+
+# If script is executed directly, run with default mode
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    sanitize_task_mode_environment "${1:-task}"
+fi

package/claude-assets/cfn-extras/skills/analytics/cfn-improvement-recommender/SKILL.md

@@ -0,0 +1,33 @@
+# Improvement Recommender Skill
+
+## Purpose
+Generate actionable improvement suggestions based on sprint retrospective data.
+
+## Core Capabilities
+- Analyze sprint performance metrics
+- Identify bottlenecks and inefficiencies
+- Recommend targeted improvements
+- Provide confidence scores for recommendations
+
+## Recommendation Categories
+- Agent Selection
+- Feedback Processing
+- Validation Criteria
+- Iteration Management
+- Complexity Estimation
+
+## Evaluation Criteria
+- Frequency of issue occurrence
+- Impact on sprint velocity
+- Cost of implementing recommendation
+- Potential performance improvement
+
+## Improvement Scoring Model
+- Confidence Level (0.0 - 1.0)
+- Expected Benefit Quantification
+- Implementation Complexity Rating
+
+## Continuous Learning
+- Track recommendation effectiveness
+- Update recommendation strategies
+- Learn from successful interventions