claude-flow-novice 2.14.34 → 2.14.36

package/claude-assets/skills/cfn-redis-coordination/invoke-waiting-mode.sh

@@ -0,0 +1,221 @@
+#!/bin/bash
+#
+# Invoke Waiting Mode - Agent Coordination for CFN Loop
+# Purpose: Handle coordination between agents using waiting mode and collection
+# Usage: invoke-waiting-mode.sh <collect|wait|signal> [task-id] [agent-id] [timeout]
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REDIS_COORD_SKILL="$SCRIPT_DIR"
+
+# Parse arguments
+COMMAND=${1:-"collect"}
+TASK_ID=${2:-""}
+AGENT_ID=${3:-""}
+TIMEOUT=${4:-120}
+
+# Redis configuration
+REDIS_HOST=${REDIS_HOST:-"localhost"}
+REDIS_PORT=${REDIS_PORT:-6379}
+REDIS_DB=${REDIS_DB:-0}
+
+# Debug output
+DEBUG=${DEBUG:-false}
+if [[ "$DEBUG" == "true" ]]; then
+    echo "DEBUG: invoke-waiting-mode called with: $*" >&2
+    echo "DEBUG: REDIS_HOST=$REDIS_HOST, REDIS_PORT=$REDIS_PORT, REDIS_DB=$REDIS_DB" >&2
+fi
+
+# Function to connect to Redis with error handling
+redis_cmd() {
+    local cmd="$1"
+    shift
+
+    if command -v redis-cli >/dev/null 2>&1; then
+        redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -n "$REDIS_DB" "$cmd" "$@" 2>/dev/null
+    else
+        echo "Warning: redis-cli not available, using mock mode" >&2
+        return 0
+    fi
+}
+
+# Function to collect agent signals
+collect_signals() {
+    local task_id="$1"
+    local agent_type="$2"
+    local timeout="${3:-120}"
+
+    echo "📡 Collecting ${agent_type} signals for task: $task_id (timeout: ${timeout}s)" >&2
+
+    local signals_key="swarm:${task_id}:signals:${agent_type}"
+    local start_time=$(date +%s)
+    local signals_collected=()
+
+    while true; do
+        # Get all available signals
+        local signals=($(redis_cmd SMEMBERS "$signals_key" 2>/dev/null || echo ""))
+
+        if [[ ${#signals[@]} -gt 0 ]]; then
+            for signal in "${signals[@]}"; do
+                if [[ ! " ${signals_collected[@]} " =~ " ${signal} " ]]; then
+                    signals_collected+=("$signal")
+                    echo "  ✓ Signal collected: $signal" >&2
+
+                    # Get detailed signal data
+                    local signal_key="swarm:${task_id}:agent:${signal}:data"
+                    local signal_data=$(redis_cmd HGETALL "$signal_key" 2>/dev/null || echo "")
+
+                    if [[ -n "$signal_data" ]]; then
+                        echo "    Data: $signal_data" >&2
+                    fi
+                fi
+            done
+        fi
+
+        # Check if we have all expected signals (this would be based on agent count)
+        local expected_signals=${EXPECTED_AGENTS:-1}
+        if [[ ${#signals_collected[@]} -ge $expected_signals ]]; then
+            echo "✅ All signals collected" >&2
+            break
+        fi
+
+        # Check timeout
+        local current_time=$(date +%s)
+        if [[ $((current_time - start_time)) -ge $timeout ]]; then
+            echo "⚠️ Timeout reached, proceeding with collected signals" >&2
+            break
+        fi
+
+        sleep 2
+    done
+
+    # Return collected signals as JSON
+    local json_output="{"
+    json_output+="\"task_id\":\"$task_id\","
+    json_output+="\"agent_type\":\"$agent_type\","
+    json_output+="\"signals\":["
+
+    for i in "${!signals_collected[@]}"; do
+        if [[ $i -gt 0 ]]; then
+            json_output+=","
+        fi
+        json_output+='"'"${signals_collected[$i]}"'"'
+    done
+
+    json_output+="],"
+    json_output+="\"count\":${#signals_collected[@]},"
+    json_output+="\"timeout\":$timeout"
+    json_output+="}"
+
+    echo "$json_output"
+}
+
+# Function to wait for specific condition
+wait_for_signal() {
+    local task_id="$1"
+    local condition="$2"
+    local timeout="${3:-120}"
+
+    echo "⏳ Waiting for signal: $condition (timeout: ${timeout}s)" >&2
+
+    local start_time=$(date +%s)
+    local condition_key="swarm:${task_id}:condition:${condition}"
+
+    while true; do
+        local condition_met=$(redis_cmd GET "$condition_key" 2>/dev/null || echo "")
+
+        if [[ "$condition_met" == "true" ]]; then
+            echo "✅ Condition met: $condition" >&2
+            redis_cmd DEL "$condition_key" 2>/dev/null
+            echo "true"
+            return 0
+        fi
+
+        # Check timeout
+        local current_time=$(date +%s)
+        if [[ $((current_time - start_time)) -ge $timeout ]]; then
+            echo "⚠️ Timeout waiting for: $condition" >&2
+            echo "false"
+            return 1
+        fi
+
+        sleep 2
+    done
+}
+
+# Function to signal completion
+signal_completion() {
+    local task_id="$1"
+    local agent_id="$2"
+    local status="${3:-complete}"
+
+    echo "📤 Signaling completion: $agent_id -> $status" >&2
+
+    # Add to completed set
+    redis_cmd SADD "swarm:${task_id}:completed" "$agent_id" 2>/dev/null || true
+
+    # Set completion status
+    redis_cmd HSET "swarm:${task_id}:agent:${agent_id}:status" "status" "$status" 2>/dev/null || true
+    redis_cmd HSET "swarm:${task_id}:agent:${agent_id}:status" "completed_at" "$(date +%s)" 2>/dev/null || true
+
+    # Broadcast completion signal
+    redis_cmd PUBLISH "swarm:${task_id}:signals" "agent:$agent_id:status:$status" 2>/dev/null || true
+
+    echo "✅ Signal sent: $agent_id completed"
+}
+
+# Main command routing
+case "$COMMAND" in
+    "collect")
+        if [[ -z "$TASK_ID" ]]; then
+            echo "Error: collect command requires task-id" >&2
+            echo "Usage: $0 collect <task-id> <agent-type> [timeout]" >&2
+            exit 1
+        fi
+        collect_signals "$TASK_ID" "${AGENT_ID:-"loop3"}" "$TIMEOUT"
+        ;;
+    "wait")
+        if [[ -z "$TASK_ID" ]] || [[ -z "$AGENT_ID" ]]; then
+            echo "Error: wait command requires task-id and condition" >&2
+            echo "Usage: $0 wait <task-id> <condition> [timeout]" >&2
+            exit 1
+        fi
+        wait_for_signal "$TASK_ID" "$AGENT_ID" "$TIMEOUT"
+        ;;
+    "signal")
+        if [[ -z "$TASK_ID" ]] || [[ -z "$AGENT_ID" ]]; then
+            echo "Error: signal command requires task-id and agent-id" >&2
+            echo "Usage: $0 signal <task-id> <agent-id> [status]" >&2
+            exit 1
+        fi
+        signal_completion "$TASK_ID" "$AGENT_ID" "$TIMEOUT"
+        ;;
+    "help"|"-h"|"--help")
+        cat <<EOF
+Usage: $0 <command> [arguments]
+
+Commands:
+  collect <task-id> <agent-type> [timeout]   Collect signals from agents
+  wait <task-id> <condition> [timeout]       Wait for condition to be met
+  signal <task-id> <agent-id> [status]       Signal agent completion
+
+Examples:
+  $0 collect cfn-cli-12345 loop3 300
+  $0 wait cfn-cli-12345 gate-passed 60
+  $0 signal cfn-cli-12345 backend-developer-1 complete
+
+Environment Variables:
+  REDIS_HOST    Redis host (default: localhost)
+  REDIS_PORT    Redis port (default: 6379)
+  REDIS_DB      Redis database (default: 0)
+  DEBUG         Enable debug output (true/false)
+EOF
+        ;;
+    *)
+        echo "Error: Unknown command '$COMMAND'" >&2
+        echo "Use '$0 help' for usage information" >&2
+        exit 1
+        ;;
+esac

package/claude-assets/skills/cfn-task-config-init/initialize-config.sh

@@ -186,8 +186,8 @@ select_agents() {
   fi
 
   # Loop 2 validators (adaptive scaling)
-  # Standard: 3-5 files → add system-architect, security
-  loop2+=("system-architect" "security-specialist")
+  # Standard: 3-5 files → add architect, security
+  loop2+=("architect" "security-specialist")
 
   # Complex/Enterprise: >5 files → add code-analyzer
   if echo "$description" | grep -iq "large\|complex\|enterprise"; then

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

@@ -1,224 +1,255 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+##############################################################################
 # CFN Task Mode Environment Sanitizer
-# Sanitizes and enforces Task-mode environment variables to prevent mode confusion
+# 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
 
-# Script configuration
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+# 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
+##############################################################################
 
-# Environment sanitization rules
 sanitize_task_mode_environment() {
-    local mode="${1:-auto}"
+    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
+}
 
-    echo "🧹 Sanitizing Task-mode environment..." >&2
+sanitize_cli_environment() {
+    echo "   Applying CLI mode sanitization..." >&2
 
-    # 1. Force CFN_MODE=task for Task mode
-    if [[ "$mode" == "task" || "$mode" == "auto" ]]; then
-        export CFN_MODE="task"
-        echo "✅ CFN_MODE forced to: $CFN_MODE" >&2
-    fi
+    # 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
 
-    # 2. Clear inherited CLI-mode variables that could cause mode confusion
-    local inherited_vars=(
-        "TASK_ID"
-        "AGENT_ID"
-        "LOOP3_AGENTS"
-        "LOOP2_VALIDATORS"
-        "PRODUCT_OWNER_ID"
-        "COORDINATOR_ID"
-        "__CFN_CLI_SPAWN"
-        "CFN_CLI_CONTEXT"
-    )
-
-    for var in "${inherited_vars[@]}"; do
-        if [[ -n "${!var:-}" ]]; then
-            echo "🗑️  Clearing inherited variable: $var (was: ${!var})" >&2
-            unset "$var"
-        fi
-    done
-
-    # 3. Set Task-mode specific environment
-    export __CFN_TASK_MODE="1"
-    export __CFN_MODE_ENFORCED="1"
-
-    # 4. Right-size Node.js heap for Task mode (prevent 16GB default)
-    if [[ -z "${NODE_OPTIONS:-}" ]]; then
-        export NODE_OPTIONS="--max-old-space-size=2048"
-    else
-        # Replace any larger heap size with Task-mode appropriate size
-        if echo "$NODE_OPTIONS" | grep -q "max-old-space-size"; then
-            export NODE_OPTIONS=$(echo "$NODE_OPTIONS" | sed 's/--max-old-space-size=[0-9]*/--max-old-space-size=2048/g')
-        else
-            export NODE_OPTIONS="$NODE_OPTIONS --max-old-space-size=2048"
-        fi
-    fi
-    echo "✅ NODE_OPTIONS set for Task mode: $NODE_OPTIONS" >&2
+    # Optimize for production CLI execution
+    export CFN_MODE="cli"
+    export CFN_SANITIZER_ACTIVE=true
 
-    # 5. Configure Task-mode specific settings
-    export CFN_MEMORY_LIMIT="2048"  # MB
-    export CFN_TIMEOUT="300"       # 5 minutes
-    export CFN_COORDINATION="file"  # Use file-based coordination
+    # Set conservative resource limits
+    ulimit -u $MAX_AGENT_PROCESSES 2>/dev/null || true
+    ulimit -v $((MAX_MEMORY_MB * 1024)) 2>/dev/null || true
 
-    echo "🎯 Task-mode environment sanitized and locked" >&2
+    # Disable debug features in production
+    export CFN_DEBUG=false
+    export CFN_VERBOSE=false
 }
 
-# Validate environment is in Task mode
-validate_task_mode_environment() {
-    local errors=0
+sanitize_task_environment() {
+    echo "   Applying Task mode sanitization..." >&2
 
-    echo "🔍 Validating Task-mode environment..." >&2
+    # Task mode allows more debugging
+    export CFN_MODE="task"
+    export CFN_SANITIZER_ACTIVE=true
 
-    # Check CFN_MODE
-    if [[ "${CFN_MODE:-}" != "task" ]]; then
-        echo "❌ CFN_MODE should be 'task', got: ${CFN_MODE:-unset}" >&2
-        ((errors++))
-    fi
+    # More permissive limits for debugging
+    ulimit -u $((MAX_AGENT_PROCESSES * 2)) 2>/dev/null || true
+    ulimit -v $((MAX_MEMORY_MB * 1024 * 2)) 2>/dev/null || true
 
-    # Check Task-mode markers
-    if [[ "${__CFN_TASK_MODE:-}" != "1" ]]; then
-        echo "❌ __CFN_TASK_MODE not set" >&2
-        ((errors++))
-    fi
+    # Enable debug features for task mode
+    export CFN_DEBUG=${CFN_DEBUG:-true}
+    export CFN_VERBOSE=${CFN_VERBOSE:-true}
+}
 
-    # Check for prohibited CLI variables
-    local prohibited_vars=(
-        "TASK_ID"
-        "AGENT_ID"
-        "LOOP3_AGENTS"
-        "__CFN_CLI_SPAWN"
-    )
-
-    for var in "${prohibited_vars[@]}"; do
-        if [[ -n "${!var:-}" ]]; then
-            echo "❌ Prohibited CLI variable found: $var=${!var}" >&2
-            ((errors++))
-        fi
-    done
-
-    # Check Node heap size
-    if echo "$NODE_OPTIONS" | grep -q "max-old-space-size"; then
-        local heap_size=$(echo "$NODE_OPTIONS" | grep -o "max-old-space-size=[0-9]*" | cut -d= -f2)
-        if [[ "$heap_size" -gt 4096 ]]; then
-            echo "❌ Node heap size too large for Task mode: ${heap_size}MB" >&2
-            ((errors++))
-        fi
-    else
-        echo "⚠️  No Node heap size specified (should be set to 2048MB)" >&2
-    fi
+sanitize_default_environment() {
+    echo "   Applying default sanitization..." >&2
 
-    if [[ $errors -eq 0 ]]; then
-        echo "✅ Task-mode environment validation passed" >&2
-        return 0
-    else
-        echo "❌ Task-mode environment validation failed ($errors errors)" >&2
-        return 1
+    # Basic sanitization for unknown modes
+    export CFN_MODE="unknown"
+    export CFN_SANITIZER_ACTIVE=true
+
+    # Conservative limits
+    ulimit -u $MAX_AGENT_PROCESSES 2>/dev/null || true
+}
+
+##############################################################################
+# 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
 }
 
-# Execute command in sanitized Task-mode environment
-exec_task_mode_sanitized() {
-    local command="$1"
-    shift
+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
+}
 
-    echo "🚀 Executing in sanitized Task-mode environment: $command" >&2
+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
+}
 
-    # Sanitize environment
-    sanitize_task_mode_environment "task"
+environment_cleanup_on_signal() {
+    local signal="$1"
+    echo "🧹 CFN Environment cleanup on signal: $signal" >&2
+    environment_cleanup_on_exit
+    exit 130
+}
 
-    # Validate environment
-    if ! validate_task_mode_environment; then
-        echo "❌ Environment validation failed, aborting execution" >&2
-        return 1
-    fi
+cleanup_cli_environment() {
+    echo "   CLI mode cleanup..." >&2
 
-    # Execute command with timeout
-    local timeout="${CFN_TIMEOUT:-300}"
-    echo "⏱️  Timeout set to ${timeout}s" >&2
-
-    if timeout "$timeout" "$command" "$@"; then
-        echo "✅ Command completed successfully" >&2
-        return 0
-    else
-        local exit_code=$?
-        if [[ $exit_code -eq 124 ]]; then
-            echo "⏰ Command timed out after ${timeout}s" >&2
-        else
-            echo "❌ Command failed with exit code: $exit_code" >&2
+    # Clean up any lingering agent processes
+    if command -v pgrep >/dev/null 2>&1; then
+        local agent_pids=$(pgrep -f "claude-flow-novice.*agent" 2>/dev/null || true)
+        if [[ -n "$agent_pids" ]]; then
+            echo "   Warning: Found agent processes: $agent_pids" >&2
         fi
-        return $exit_code
     fi
 }
 
-# Show usage
-show_usage() {
-    cat <<'EOF'
-CFN Task Mode Environment Sanitizer
+cleanup_task_environment() {
+    echo "   Task mode cleanup..." >&2
+    # Task mode cleanup - more permissive
+}
 
-USAGE:
-    source "$(dirname "${BASH_SOURCE[0]}")/task-mode-env-sanitizer.sh"
+force_environment_cleanup() {
+    echo "🚨 Force cleanup triggered!" >&2
 
-    # Environment Sanitization
-    sanitize_task_mode_environment [mode]     # Sanitize environment (auto|task|cli)
-    validate_task_mode_environment             # Validate current environment
+    # 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
 
-    # Command Execution
-    exec_task_mode_sanitized <command> [args...]  # Execute command in sanitized environment
+    # Force exit
+    exit 1
+}
 
-EXAMPLES:
-    # Sanitize current shell
-    sanitize_task_mode_environment task
+##############################################################################
+# Utility Functions
+##############################################################################
 
-    # Execute validator with sanitized environment
-    exec_task_mode_sanitized node validate-code.js
+check_environment_health() {
+    local mode="${1:-${CFN_SANITIZER_STATE[mode]}}"
 
-    # Run with environment validation
-    if validate_task_mode_environment; then
-        echo "Environment is safe for Task mode"
+    if [[ "${CFN_SANITIZER_STATE[initialized]}" != "true" ]]; then
+        echo "❌ Environment sanitizer not initialized" >&2
+        return 1
     fi
 
-ENVIRONMENT VARIABLES:
-    CFN_MODE               # Forced to 'task' for Task mode
-    __CFN_TASK_MODE        # Set to '1' in Task mode
-    NODE_OPTIONS           # Limited to 2048MB heap in Task mode
-    CFN_MEMORY_LIMIT       # Memory limit in MB (default: 2048)
-    CFN_TIMEOUT            # Command timeout in seconds (default: 300)
-    CFN_COORDINATION       # Coordination method: 'file' for Task mode
+    # 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
 
-EOF
+    # 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
 }
 
-# Main execution block
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    if [[ "$1" == "--help" || "$1" == "-h" ]]; then
-        show_usage
-        exit 0
-    fi
+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"
+}
 
-    # Execute operation if provided
-    if [[ $# -gt 0 ]]; then
-        case "$1" in
-            "sanitize")
-                sanitize_task_mode_environment "${2:-auto}"
-                ;;
-            "validate")
-                validate_task_mode_environment
-                ;;
-            "exec")
-                shift
-                exec_task_mode_sanitized "$@"
-                ;;
-            *)
-                echo "Unknown operation: $1" >&2
-                echo "Use --help for usage information" >&2
-                exit 1
-                ;;
-        esac
-    else
-        echo "CFN Task Mode Environment Sanitizer" >&2
-        echo "Current mode: ${CFN_MODE:-unset}" >&2
-        echo "Node options: ${NODE_OPTIONS:-unset}" >&2
-        echo "Use --help for usage information" >&2
-    fi
+##############################################################################
+# 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