Fix conservative overcurrent mode never reducing charger limit

Conservative mode clamped phase_limit at 0 (max(0, phase_limit + avail)),
returning a positive value that PowerAllocator read as surplus, so cuts
never fired and the charger was never throttled during overcurrent. Emit
the real negative deficit immediately instead, matching the
relative-availability contract used by the optimised/default balancers.
Conservative stays distinct from optimised by cutting right away rather
than waiting for cumulative trip risk to cross the threshold.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Steven

custom_components/evse_load_balancer/balancers/optimised_load_balancer.py

@@ -88,8 +88,12 @@ def update(self, avail: float, now: int) -> float:
                     self._cumulative_trip_risk = 0.0
                     self.phase_limit = avail
             else:
+                # Conservative mode: reduce immediately by emitting the real
+                # negative deficit so the PowerAllocator distributes cuts.
+                # This is the safer (more aggressive) mode, cutting right away
+                # instead of waiting for the cumulative trip risk to build up.
                 self._cumulative_trip_risk = 0.0
-                self.phase_limit = max(0, self.phase_limit + avail)
+                self.phase_limit = avail
         else:
             risk_decay = self._risk_decay_per_second * elapsed
             self._cumulative_trip_risk = max(

tests/balancers/test_optimised_load_balancer.py

@@ -89,10 +89,19 @@ def test_conservative_mode_immediate_reduction():
 
     for phase in Phase:
         assert limits_one[phase] == 20
-        assert limits_two[phase] == 15
+        # Conservative mode emits the real negative deficit immediately so the
+        # PowerAllocator distributes the cut across the chargers.
+        assert limits_two[phase] == -5
 
 
-def test_conservative_mode_never_goes_below_zero():
+def test_conservative_mode_emits_negative_deficit():
+    """Conservative mode must surface a negative availability during overcurrent.
+
+    Regression test: previously the overcurrent branch clamped at 0
+    (``max(0, phase_limit + avail)``) and therefore never returned a negative
+    value, so PowerAllocator's ``_distribute_cuts`` was never triggered and the
+    charger limit was never reduced.
+    """
     lb = OptimisedLoadBalancer(
         max_limits=dict.fromkeys(Phase, 25),
         overcurrent_mode=OvercurrentMode.CONSERVATIVE,
@@ -105,7 +114,10 @@ def test_conservative_mode_never_goes_below_zero():
 
     for phase in Phase:
         assert limits_one[phase] == 5
-        assert limits_two[phase] == 0
+        # A sustained overcurrent must produce a negative availability (a cut),
+        # not a clamped-at-zero value.
+        assert limits_two[phase] == -10
+        assert limits_two[phase] < 0
 
 
 def test_conservative_mode_allows_increases():
@@ -123,7 +135,9 @@ def test_conservative_mode_allows_increases():
 
     for phase in Phase:
         assert limits_one[phase] == 10
-        assert limits_two[phase] == 5
+        # Overcurrent is emitted as a negative deficit (immediate cut)...
+        assert limits_two[phase] == -5
+        # ...and recovery still surfaces the available surplus.
         assert limits_three[phase] == 15
 
 
@@ -170,5 +184,8 @@ def test_conservative_vs_optimised_mode_behavior():
     for phase in Phase:
         assert limits_conservative_one[phase] == 20
         assert limits_optimised_one[phase] == 20
-        assert limits_conservative_two[phase] == 17
+        # Conservative reduces immediately, emitting the negative deficit, while
+        # optimised tolerates the temporary overcurrent until trip risk builds.
+        assert limits_conservative_two[phase] == -3
+        assert limits_conservative_two[phase] < limits_optimised_two[phase]
         assert limits_optimised_two[phase] == 20