feat: Update optimizer to use three-constraint intelligent model

The optimizer now uses the same intelligent three-constraint model
as the batch analyzer for consistent recommendations:

- Calculates server capacity upfront
- Uses three-constraint intelligent function
- Falls back to profiles if available (for advanced users)
- Shows limiting factor for each recommendation
- Ensures fair distribution across all domains

This brings the optimizer in line with the batch analyzer and provides
the most intelligent, fair, and safe recommendations possible.

lib/php-calculator-improved.sh

@@ -284,6 +284,153 @@ detect_mysql_memory_usage() {
     fi
 }
 
+# ============================================================================
+# NEW: CALCULATE SERVER TOTAL CAPACITY
+# ============================================================================
+# Calculate the total max_children the entire server can support
+# Usage: calculate_server_capacity <total_ram_mb>
+# Returns: total_capacity|available_memory|memory_per_process|reason
+calculate_server_capacity() {
+    local total_ram_mb="$1"
+
+    if [ -z "$total_ram_mb" ] || [ "$total_ram_mb" -lt 512 ]; then
+        echo "0|0|20|Insufficient RAM for calculation"
+        return
+    fi
+
+    # Calculate system reserve (dynamic percentage-based)
+    local reserve_result
+    reserve_result=$(calculate_system_reserve "$total_ram_mb")
+    local reserved_mb
+    reserved_mb=$(get_field "$reserve_result" 1)
+
+    # Account for MySQL memory (critical on shared hosting!)
+    local mysql_memory_mb=0
+    local mysql_info
+    mysql_info=$(detect_mysql_memory_usage 2>/dev/null)
+    if [ $? -eq 0 ]; then
+        mysql_memory_mb=$(echo "$mysql_info" | cut -d'|' -f3)
+    fi
+
+    # Available memory for PHP-FPM (after system + MySQL reserves)
+    local available_mb=$((total_ram_mb - reserved_mb - mysql_memory_mb))
+
+    # Safety check: never allow PHP-FPM to use more than 60% of RAM
+    local max_php_fpm=$((total_ram_mb * 60 / 100))
+    if [ "$available_mb" -gt "$max_php_fpm" ]; then
+        available_mb=$max_php_fpm
+    fi
+
+    # Conservative memory per process for safety (20MB)
+    local memory_per_process=20
+
+    # Total capacity = available memory / memory per process
+    local total_capacity=$((available_mb / memory_per_process))
+
+    # Sanity checks
+    [ "$total_capacity" -lt 5 ] && total_capacity=5
+    [ "$total_capacity" -gt 500 ] && total_capacity=500
+
+    echo "$total_capacity|$available_mb|$memory_per_process|Server can support $total_capacity total max_children"
+}
+
+# ============================================================================
+# NEW: GET DOMAIN TRAFFIC PERCENTAGE
+# ============================================================================
+# Calculate what percentage of total server traffic this domain handles
+# Usage: get_domain_traffic_percentage <username> <domain> <all_domains_list>
+# Returns: percentage|request_count|reason
+get_domain_traffic_percentage() {
+    local username="$1"
+    local domain="$2"
+    local all_domains="$3"
+
+    if [ -z "$domain" ] || [ -z "$all_domains" ]; then
+        echo "50|0|Insufficient data"
+        return
+    fi
+
+    # Find access logs for this domain
+    local access_log
+    access_log=$(find /home/"$username"/*/logs -name "*access*log*" 2>/dev/null | grep "$domain" | head -1)
+
+    if [ -z "$access_log" ] || [ ! -f "$access_log" ]; then
+        # No specific log found, assume equal distribution
+        local domain_count
+        domain_count=$(echo "$all_domains" | wc -l)
+        local percentage=$((100 / domain_count))
+        echo "$percentage|0|No logs found, assuming equal distribution"
+        return
+    fi
+
+    # Count requests for this domain from last 7 days
+    local domain_requests
+    domain_requests=$(find "$access_log" -mtime -7 -exec wc -l {} \; 2>/dev/null | awk '{print $1}')
+    [ -z "$domain_requests" ] && domain_requests=0
+
+    if [ "$domain_requests" -eq 0 ]; then
+        # No recent traffic, use equal distribution
+        local domain_count
+        domain_count=$(echo "$all_domains" | wc -l)
+        local percentage=$((100 / domain_count))
+        echo "$percentage|0|No recent traffic"
+        return
+    fi
+
+    # Count total requests across all domains
+    local total_requests=0
+    while IFS= read -r d; do
+        [ -z "$d" ] && continue
+        local d_log
+        d_log=$(find /home/"$username"/*/logs -name "*access*log*" 2>/dev/null | head -1)
+        if [ -f "$d_log" ]; then
+            local d_count
+            d_count=$(find "$d_log" -mtime -7 -exec wc -l {} \; 2>/dev/null | awk '{print $1}')
+            total_requests=$((total_requests + d_count))
+        fi
+    done <<< "$all_domains"
+
+    if [ "$total_requests" -eq 0 ]; then
+        echo "50|$domain_requests|Insufficient total traffic"
+        return
+    fi
+
+    # Calculate percentage
+    local percentage=$((domain_requests * 100 / total_requests))
+    [ "$percentage" -lt 1 ] && percentage=1
+    [ "$percentage" -gt 99 ] && percentage=99
+
+    echo "$percentage|$domain_requests|Based on $total_requests total requests"
+}
+
+# ============================================================================
+# NEW: CALCULATE FAIR SHARE BASED ON TRAFFIC
+# ============================================================================
+# Calculate this domain's fair share of server capacity based on traffic percentage
+# Usage: calculate_max_children_fair_share <total_capacity> <traffic_percentage>
+# Returns: fair_share_max|reason
+calculate_max_children_fair_share() {
+    local total_capacity="$1"
+    local traffic_percentage="$2"
+
+    if [ -z "$total_capacity" ] || [ -z "$traffic_percentage" ]; then
+        echo "20|Invalid parameters"
+        return
+    fi
+
+    # Calculate fair share: total capacity × traffic percentage
+    local fair_share=$((total_capacity * traffic_percentage / 100))
+
+    # Apply hard limits
+    if [ "$fair_share" -lt 5 ]; then
+        echo "5|Fair share is very small (minimum enforced)"
+    elif [ "$fair_share" -gt 150 ]; then
+        echo "150|Fair share exceeds shared hosting limit (capped at 150)"
+    else
+        echo "$fair_share|Fair share: $traffic_percentage% of $total_capacity total"
+    fi
+}
+
 # ============================================================================
 # NEW: RECOMMEND PM MODE (static/dynamic/ondemand)
 # ============================================================================
@@ -406,6 +553,92 @@ calculate_optimal_php_settings() {
     echo "$final_max_children|$pm_mode|$min_spare|$max_spare|$reason_prefix: $pm_reason"
 }
 
+# ============================================================================
+# NEW: THREE-CONSTRAINT INTELLIGENT OPTIMIZATION
+# ============================================================================
+# Calculate optimal settings using three constraints for maximum intelligence:
+# 1. Memory constraint - what available RAM allows
+# 2. Traffic constraint - what actual usage suggests
+# 3. Fair share constraint - proportional allocation based on traffic
+# Uses the MINIMUM of all three for maximum safety and fairness
+# Usage: calculate_optimal_php_settings_intelligent <username> <total_ram_mb> <total_server_capacity> <traffic_percentage>
+# Returns: max_children|pm_mode|min_spare|max_spare|limiting_factor|reason
+calculate_optimal_php_settings_intelligent() {
+    local username="$1"
+    local total_ram_mb="$2"
+    local total_server_capacity="$3"
+    local traffic_percentage="$4"
+
+    if [ -z "$username" ] || [ -z "$total_ram_mb" ] || [ -z "$total_server_capacity" ]; then
+        echo "0|dynamic|1|5|ERROR|Invalid parameters"
+        return
+    fi
+
+    # Default traffic percentage if not provided (equal distribution)
+    [ -z "$traffic_percentage" ] && traffic_percentage=50
+
+    # CONSTRAINT 1: Memory-based max (what RAM allows)
+    local memory_result
+    memory_result=$(calculate_max_children_memory_based "$username" "$total_ram_mb")
+    local memory_based_max
+    memory_based_max=$(get_field "$memory_result" 1)
+
+    # CONSTRAINT 2: Traffic-based max (what traffic patterns suggest)
+    local traffic_result
+    traffic_result=$(calculate_peak_concurrent_requests_improved "$username" 7)
+    local peak_concurrent stability_factor
+    peak_concurrent=$(get_field "$traffic_result" 1)
+    stability_factor=$(get_field "$traffic_result" 2)
+
+    local traffic_based_max=0
+    if [ "$peak_concurrent" -gt 0 ]; then
+        local traffic_calc
+        traffic_calc=$(calculate_max_children_traffic_based "$peak_concurrent" "$stability_factor")
+        traffic_based_max=$(get_field "$traffic_calc" 1)
+    else
+        traffic_based_max=$memory_based_max  # No traffic data, use memory as basis
+    fi
+
+    # CONSTRAINT 3: Fair share (proportional allocation based on traffic %)
+    local fair_share_result
+    fair_share_result=$(calculate_max_children_fair_share "$total_server_capacity" "$traffic_percentage")
+    local fair_share_max
+    fair_share_max=$(get_field "$fair_share_result" 1)
+
+    # USE THE MINIMUM OF ALL THREE CONSTRAINTS
+    local final_max_children="$memory_based_max"
+    local limiting_factor="Memory (${memory_based_max}MB available)"
+
+    if [ "$traffic_based_max" -lt "$final_max_children" ]; then
+        final_max_children="$traffic_based_max"
+        limiting_factor="Traffic (peak ${peak_concurrent} concurrent)"
+    fi
+
+    if [ "$fair_share_max" -lt "$final_max_children" ]; then
+        final_max_children="$fair_share_max"
+        limiting_factor="Fair share (${traffic_percentage}% of server capacity)"
+    fi
+
+    # CRITICAL: Ensure we never recommend 0 or invalid values
+    if [ -z "$final_max_children" ] || [ "$final_max_children" -le 0 ]; then
+        final_max_children="20"
+        limiting_factor="Safe default (calculation failed)"
+    fi
+
+    # Recommend pm mode
+    local pm_result
+    pm_result=$(recommend_pm_mode "$peak_concurrent" "$((peak_concurrent / 2))" "$stability_factor")
+    local pm_mode min_spare max_spare pm_reason
+    pm_mode=$(get_field "$pm_result" 1)
+    min_spare=$(get_field "$pm_result" 2)
+    max_spare=$(get_field "$pm_result" 3)
+    pm_reason=$(get_field "$pm_result" 4)
+
+    # Return with detailed explanation
+    local reason="3-constraint intelligent: Mem=$memory_based_max, Traffic=$traffic_based_max, Share=$fair_share_max → $limiting_factor"
+    echo "$final_max_children|$pm_mode|$min_spare|$max_spare|$limiting_factor|$reason"
+}
+
 # ============================================================================
 # Export functions for use in other scripts
 # ============================================================================
@@ -414,6 +647,10 @@ export -f calculate_max_children_memory_based
 export -f calculate_peak_concurrent_requests_improved
 export -f calculate_max_children_traffic_based
 export -f detect_mysql_memory_usage
+export -f calculate_server_capacity
+export -f get_domain_traffic_percentage
+export -f calculate_max_children_fair_share
 export -f recommend_pm_mode
 export -f calculate_optimal_php_settings
+export -f calculate_optimal_php_settings_intelligent
 export -f get_field

modules/performance/php-fpm-batch-analyzer.sh

@@ -65,13 +65,29 @@ cecho "  Scan Date: ${WHITE}$(date)${NC}"
 echo ""
 
 # ============================================================================
-# DOMAIN ENUMERATION & ANALYSIS
+# STEP 1: CALCULATE SERVER CAPACITY
 # ============================================================================
 
-cecho "${WHITE}${BOLD}DOMAIN-BY-DOMAIN ANALYSIS${NC}"
+cecho "${WHITE}${BOLD}STEP 1: SERVER CAPACITY ANALYSIS${NC}"
 cecho "${CYAN}─────────────────────────────────────────────────────────────────────${NC}"
+
+server_capacity_result=$(calculate_server_capacity "$TOTAL_RAM_MB")
+server_capacity=$(echo "$server_capacity_result" | cut -d'|' -f1)
+available_memory=$(echo "$server_capacity_result" | cut -d'|' -f2)
+memory_per_process=$(echo "$server_capacity_result" | cut -d'|' -f3)
+
+cecho "  Available RAM for PHP-FPM: ${WHITE}${available_memory}MB${NC}"
+cecho "  Memory per process: ${WHITE}${memory_per_process}MB${NC}"
+cecho "  Server capacity: ${WHITE}${server_capacity}${NC} total max_children"
 echo ""
 
+# ============================================================================
+# STEP 2: DOMAIN ENUMERATION & TRAFFIC ANALYSIS
+# ============================================================================
+
+cecho "${WHITE}${BOLD}STEP 2: DOMAIN ENUMERATION & TRAFFIC ANALYSIS${NC}"
+cecho "${CYAN}─────────────────────────────────────────────────────────────────────${NC}"
+
 # Get all users and domains
 users=$(list_all_users)
 
@@ -88,6 +104,8 @@ declare -a pm_max_requests
 declare -a pm_min_spare
 declare -a pm_max_spare
 declare -a pm_idle_timeout
+declare -a traffic_percentage_arr
+declare -a limiting_factor_arr
 
 TOTAL_DOMAINS=0
 TOTAL_CURRENT_MEMORY=0
@@ -137,11 +155,19 @@ while IFS= read -r username; do
         pm_idle=$(grep "^pm.process_idle_timeout = " "$pool_config" 2>/dev/null | awk -F'=' '{print $2}' | tr -d ' ')
         pm_idle_timeout[$TOTAL_DOMAINS]="${pm_idle:-10}"
 
-        # Calculate recommended using improved algorithm
+        # Calculate recommended using THREE-CONSTRAINT INTELLIGENT ALGORITHM
-        recommended_result=$(calculate_optimal_php_settings "$username" "$TOTAL_RAM_MB" 2>/dev/null || echo "20||")
+        # Get traffic percentage for this domain
+        traffic_percentage=$(get_domain_traffic_percentage "$username" "$domain" "$user_domains" 2>/dev/null | cut -d'|' -f1)
+        traffic_percentage=${traffic_percentage:-50}
+
+        # Use intelligent three-constraint model: MIN(memory, traffic, fair_share)
+        recommended_result=$(calculate_optimal_php_settings_intelligent "$username" "$TOTAL_RAM_MB" "$server_capacity" "$traffic_percentage" 2>/dev/null || echo "20|dynamic|1|5|ERROR|Failed")
         recommended=$(echo "$recommended_result" | cut -d'|' -f1)
         recommended=${recommended:-20}
+        limiting_factor=$(echo "$recommended_result" | cut -d'|' -f5)
         recommended_max_children[$TOTAL_DOMAINS]="$recommended"
+        traffic_percentage_arr[$TOTAL_DOMAINS]="$traffic_percentage"
+        limiting_factor_arr[$TOTAL_DOMAINS]="$limiting_factor"
 
         # Calculate memory impact (assuming 20MB per process on average)
         current_memory=$((current * 20))
@@ -261,7 +287,8 @@ for idx in "${sorted_indices[@]}"; do
     if [ "$optimize" == "YES" ]; then
         cecho "${YELLOW}[$idx]${NC} $domain"
         cecho "     Owner: $owner"
-        cecho "     Traffic: $traffic_indicator"
+        cecho "     Traffic: $traffic_indicator (${traffic_percentage_arr[$idx]}% of server)"
+        cecho "     Limiting Factor: ${limiting_factor_arr[$idx]}"
         cecho ""
         cecho "     ${BOLD}Current Pool Settings:${NC}"
         cecho "       pm.max_children: ${RED}$current${NC} → Recommended: ${GREEN}$recommended${NC}"

modules/performance/php-optimizer.sh

@@ -2459,7 +2459,16 @@ optimize_level_5_everything() {
         echo ""
     fi
 
-    cecho "${CYAN}STEP 2: Calculating Recommendations${NC}"
+    cecho "${CYAN}STEP 2: Calculating Intelligent Recommendations${NC}"
+    echo ""
+
+    # Calculate server capacity for fair share allocation
+    local server_capacity_result
+    server_capacity_result=$(calculate_server_capacity "$TOTAL_RAM_MB")
+    local server_capacity
+    server_capacity=$(echo "$server_capacity_result" | cut -d'|' -f1)
+    cecho "  Server PHP-FPM capacity: ${WHITE}${server_capacity}${NC} max_children"
+    cecho "  Using three-constraint model: Memory + Traffic + Fair Share"
     echo ""
 
     # Check if profiles exist
@@ -2502,24 +2511,30 @@ optimize_level_5_everything() {
                 current_max="?"
             fi
 
-            # Get recommendations - use profile if available, otherwise use traffic-based
+            # Get recommendations using THREE-CONSTRAINT INTELLIGENT MODEL
             local recommended_max
             local recommended_memory
             local recommended_requests
+            local traffic_pct=50  # Default if no data
 
+            # Get traffic percentage for this domain
             if [ "$profiles_exist" = "1" ] && [ -f "/tmp/php-domain-profiles/$domain.profile" ]; then
+                # Use profile data if available
                 recommended_max=$(get_max_children_recommendation "$domain" "$username")
                 recommended_memory=$(get_memory_limit_recommendation "$domain" "$username")
                 recommended_requests=$(get_max_requests_recommendation "$domain")
             else
-                # Fallback to traffic-based (old method)
+                # Use intelligent three-constraint model
-                local traffic_rpm
+                traffic_pct=$(get_domain_traffic_percentage "$username" "$domain" "$user_domains" 2>/dev/null | cut -d'|' -f1)
-                traffic_rpm=$(get_domain_peak_concurrent "$domain" 2>/dev/null || echo "0")
+                traffic_pct=${traffic_pct:-50}
-                [ "$traffic_rpm" = "?" ] && traffic_rpm="0"
 
-                recommended_max=$((traffic_rpm > 5 ? traffic_rpm + 10 : 5))
+                # Call intelligent three-constraint function
-                recommended_memory=$(calculate_optimal_memory_limit "$username" "$domain" "$traffic_rpm")
+                local intel_result
-                recommended_requests=$(calculate_optimal_max_requests "$traffic_rpm")
+                intel_result=$(calculate_optimal_php_settings_intelligent "$username" "$TOTAL_RAM_MB" "$server_capacity" "$traffic_pct" 2>/dev/null || echo "20|dynamic|1|5|ERROR|Failed")
+
+                recommended_max=$(echo "$intel_result" | cut -d'|' -f1)
+                recommended_memory=$(calculate_optimal_memory_limit "$username" "$domain" "$recommended_max" 2>/dev/null || echo "128M")
+                recommended_requests=$(calculate_optimal_max_requests "$recommended_max" 2>/dev/null || echo "0")
             fi
 
             recommended_max_children["$domain"]="$recommended_max"