fix: treat MaxConcurrentReconciles=0 as unlimited

Fixes CodeRabbit review feedback where value 0 should mean "unlimited"
instead of falling back to controller-runtime default.

Changes:
- Map value 0 to 1000 (effectively unlimited) in GetMaxConcurrentReconciles()
- Change condition from > 0 to >= 0 to always apply the option
- Update documentation to clarify 0 = unlimited behavior
- Update Helm values.yaml comment

This ensures that setting MAX_CONCURRENT_RECONCILES=0 provides true
unlimited concurrency as documented, rather than defaulting to 1.

Author: flemzord

helm/operator/STACK_CONCURRENCY.md

@@ -25,8 +25,8 @@ helm install operator ./helm/operator \
 ### Default Behavior
 
 - **Default value: `5`** (good balance for most clusters)
-- Set to `0` to use controller-runtime default (typically 1 concurrent reconciliation)
-- For near-unlimited concurrency, set a high value like `1000`
+- Set to `0` for unlimited concurrency (mapped to 1000 internally)
+- Any positive value (1-999) sets that exact limit
 
 ## Recommended Values
 
@@ -230,6 +230,10 @@ spec:
 func GetMaxConcurrentReconciles() int {
     if v := os.Getenv("MAX_CONCURRENT_RECONCILES"); v != "" {
         if n, err := strconv.Atoi(v); err == nil && n >= 0 {
+            if n == 0 {
+                // Treat 0 as "unlimited" by using a very high value
+                return 1000
+            }
             return n
         }
     }

helm/operator/values.yaml

@@ -50,7 +50,7 @@ operator:
   enableLeaderElection: true
 
   # Maximum number of concurrent reconciliations (applies to all resources: stacks, modules, etc.)
-  # Set to 0 for unlimited
+  # Set to 0 for unlimited (mapped to 1000 internally)
   # Recommended values: 5 for small/medium clusters, 10 for large, 20 for XL
   # @section -- Concurrency Control
   maxConcurrentReconciles: 5

internal/core/concurrency.go

@@ -6,10 +6,15 @@ import (
 )
 
 // GetMaxConcurrentReconciles returns the maximum number of concurrent reconciliations
-// from the MAX_CONCURRENT_RECONCILES environment variable, or a default value of 5
+// from the MAX_CONCURRENT_RECONCILES environment variable, or a default value of 5.
+// A value of 0 is treated as "unlimited" and mapped to a very high value (1000).
 func GetMaxConcurrentReconciles() int {
 	if v := os.Getenv("MAX_CONCURRENT_RECONCILES"); v != "" {
 		if n, err := strconv.Atoi(v); err == nil && n >= 0 {
+			if n == 0 {
+				// Treat 0 as "unlimited" by using a very high value
+				return 1000
+			}
 			return n
 		}
 	}

internal/core/reconciler.go

@@ -234,8 +234,8 @@ func withReconciler[T client.Object](controller ObjectController[T], opts ...Rec
 			}
 		}
 
-		// Apply MaxConcurrentReconciles if specified (0 means use controller-runtime default)
-		if options.MaxConcurrentReconciles > 0 {
+		// Apply MaxConcurrentReconciles if specified (always apply when >= 0)
+		if options.MaxConcurrentReconciles >= 0 {
 			b = b.WithOptions(controllerconfig.Options{
 				MaxConcurrentReconciles: options.MaxConcurrentReconciles,
 			})