Stop the low-priority cascade flapping on broken-cloud days (v2.37.0)

Confirmed live 2026-09-10, a heavy broken-cloud day with an EV home far
below target: the miner, pool pump and boiler switched fully on and off
every 10-20 minutes all afternoon. Two amplifiers, fixed here:

1. Fictional modelled surplus on turn-on. "Überschuss" briefly read up to
   +7 kW while the Tibber meter showed ~0.5 kW real feed-in — the wallbox
   reservation was lagging a gross-PV upswing and the car was ramping up
   to take the rest. The whole low-priority cascade switched on chasing
   surplus that wasn't leaving the house, then shed a few cycles later.
   Fix: a device may only be *switched on* via the modelled-surplus path
   (`remaining_surplus > need`) while the export meter also shows a real
   feed-in covering its own draw, minus what devices already turned on
   this cycle have claimed from the same reading (cumulative_export_
   committed). Only while an export sensor is configured and the sun is
   up; an already-on device is never shed by this (its draw is already in
   the meter), it only blocks a fresh turn-on. New decision-log reason
   "Wartet — keine echte Einspeisung". Const EXPORT_CORROBORATION_MARGIN_KW.

2. The reservation's gross-PV gate releasing on brief cloud gaps. When
   gross PV dipped under WALLBOX_MIN_PV_FOR_RESERVATION_KW (1.7 kW) the
   whole ~deadline-pace wallbox reservation dropped to 0 the same cycle,
   handing it to the cascade, then snapped back to full when the sun
   returned — "Grundlast" toggling 0.3 <-> 10 kW. Fix: once armed, the
   gate only releases after gross PV has stayed below the floor for
   WALLBOX_PV_GATE_RELEASE_CYCLES (15 min) in a row. Arming stays instant.
   New per-wallbox counter _wallbox_pv_gate_below_cycles.

Both are no-ops without an export sensor / a wallbox configured. The
underlying base_load desync spike (a fresh wallbox-power reading
subtracted from a stale house-load reading briefly inflating the honest
base load) is a separate, known issue left for a later pass.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: xchillxx

custom_components/surplus_load_switch/const.py

@@ -203,6 +203,18 @@ def _minutes_to_cycles(minutes: float) -> int:
 # the full reservation arms at 2.0 kW gross PV and drops again below
 # 1.7 kW.
 WALLBOX_MIN_PV_HYSTERESIS_KW = 0.3
+# v2.37: once the reservation's gross-PV gate has armed, keep it armed
+# until gross PV has stayed below the floor for this many *consecutive*
+# cycles — not the instant it dips once. A car that's home and below
+# target still needs its full day's charge; a passing cloud that drops
+# gross PV under 1.7 kW for a few minutes shouldn't release the entire
+# ~deadline-pace reservation to the device cascade and then yank it back
+# when the sun returns. Confirmed live 2026-09-10 (broken-cloud day):
+# "Grundlast" toggling 0.3 <-> 10 kW every ~10-15 min, miner + pool pump
+# + boiler switching fully on and off with each swing. Arming stays
+# instant (PV genuinely there -> reserve at once); only the release is
+# held.
+WALLBOX_PV_GATE_RELEASE_CYCLES = _minutes_to_cycles(15)
 # How far a wallbox's real measured draw may exceed what was actually
 # reserved for it before that alone counts as "starved" (see
 # wallbox_starved in coordinator.py), independent of whether the
@@ -504,6 +516,21 @@ def _minutes_to_cycles(minutes: float) -> int:
 EXPORT_GATE_MEDIAN_WINDOW = 3
 EXPORT_GATE_SOC_OVERRIDE = 99.0
 
+# v2.37: a device may only be *switched on* via the modelled-surplus path
+# (`remaining_surplus > need`) while the meter also shows the household is
+# really exporting at least that device's own draw (minus what devices
+# already granted this cycle have claimed from the same reading). The
+# modelled surplus can briefly read strongly positive when the wallbox
+# reservation lags a gross-PV upswing — confirmed live 2026-09-10, a
+# broken-cloud day: "Überschuss" spiking to +7 kW while the Tibber meter
+# showed ~0.5 kW real feed-in (the car was ramping up and taking the
+# rest), the whole low-priority cascade switching fully on, then off
+# again a few minutes later. Only enforced while battery_full_projection_
+# applies (daytime) and an export sensor is configured; an already-on
+# device is never shed by this (its own draw is already in the meter
+# reading) — it only blocks a fresh turn-on.
+EXPORT_CORROBORATION_MARGIN_KW = 0.0
+
 # Default monthly solar offsets (hours after sunrise until PV is useful)
 DEFAULT_SOLAR_OFFSETS = [3.5, 3.0, 2.5, 2.0, 2.0, 2.2, 2.2, 2.0, 2.5, 3.0, 3.5, 4.0]
 

custom_components/surplus_load_switch/coordinator.py

@@ -72,6 +72,7 @@
     DEFAULT_SOLAR_OFFSETS,
     DISCHARGE_SMOOTHING_SAMPLES,
     DOMAIN,
+    EXPORT_CORROBORATION_MARGIN_KW,
     EXPORT_GATE_MEDIAN_WINDOW,
     EXPORT_GATE_MIN_KW,
     EXPORT_GATE_RELEASE_KW,
@@ -99,6 +100,7 @@
     WALLBOX_MIN_PV_FOR_RESERVATION_KW,
     WALLBOX_MIN_PV_HYSTERESIS_KW,
     WALLBOX_OVERDRAW_MARGIN_KW,
+    WALLBOX_PV_GATE_RELEASE_CYCLES,
     WALLBOX_RELIEF_CYCLES,
     WALLBOX_STARVED_RESERVED_RATIO,
     WALLBOX_TARGET_MIN_HOURS,
@@ -491,6 +493,12 @@ def __init__(self, hass: HomeAssistant, config: dict[str, Any], entry_id: str) -
         # every cycle. Starts closed (below floor) — a genuine morning
         # ramp opens it within a cycle or two.
         self._wallbox_pv_gate_open: dict[str, bool] = {}
+        # Per-wallbox count of consecutive cycles gross PV has been below
+        # the release floor while the gate is armed — the gate only
+        # actually releases once this reaches WALLBOX_PV_GATE_RELEASE_CYCLES,
+        # so a brief cloud gap doesn't drop the whole reservation. Reset to
+        # 0 on any cycle PV is back above the floor. See _wallbox_reserved_kw.
+        self._wallbox_pv_gate_below_cycles: dict[str, int] = {}
         # Cached price-optimized-forcing slot selection per device (see
         # _price_optimized_force_active/price_source.py) — avoids
         # calling tibber.get_prices every 60-second cycle. Keyed by
@@ -1275,15 +1283,31 @@ def _wallbox_reserved_kw(
         # Below WALLBOX_MIN_PV_FOR_RESERVATION_KW of gross production the
         # car's charger can't sustain a charge no matter how the house-load
         # math works out, so reserving surplus for it only keeps managed
-        # devices off for a car that isn't charging. Hysteresis via a latch
-        # (needs +WALLBOX_MIN_PV_HYSTERESIS_KW to re-arm) so a PV reading
-        # sitting on the threshold doesn't flip the reservation, and every
-        # lower-priority device's on/off state with it, every cycle.
+        # devices off for a car that isn't charging. Magnitude hysteresis
+        # via a latch (needs +WALLBOX_MIN_PV_HYSTERESIS_KW to arm) so a PV
+        # reading sitting on the threshold doesn't flip the reservation.
+        # On top of that, once armed the gate only *releases* after gross
+        # PV has stayed below the floor for WALLBOX_PV_GATE_RELEASE_CYCLES
+        # in a row: a car that's home and below target still needs its
+        # whole day's charge, and letting a passing cloud drop the entire
+        # ~deadline-pace reservation to 0 — then snap it back when the sun
+        # returns — flaps every lower-priority device on and off with it
+        # (confirmed live 2026-09-10, broken-cloud day). Arming stays
+        # instant.
         gate_open = self._wallbox_pv_gate_open.get(wallbox_id, False)
-        threshold = WALLBOX_MIN_PV_FOR_RESERVATION_KW + (
-            0.0 if gate_open else WALLBOX_MIN_PV_HYSTERESIS_KW
-        )
-        gate_open = solar_kw >= threshold
+        if not gate_open:
+            gate_open = solar_kw >= (
+                WALLBOX_MIN_PV_FOR_RESERVATION_KW + WALLBOX_MIN_PV_HYSTERESIS_KW
+            )
+            if gate_open:
+                self._wallbox_pv_gate_below_cycles[wallbox_id] = 0
+        elif solar_kw < WALLBOX_MIN_PV_FOR_RESERVATION_KW:
+            below = self._wallbox_pv_gate_below_cycles.get(wallbox_id, 0) + 1
+            self._wallbox_pv_gate_below_cycles[wallbox_id] = below
+            if below >= WALLBOX_PV_GATE_RELEASE_CYCLES:
+                gate_open = False
+        else:
+            self._wallbox_pv_gate_below_cycles[wallbox_id] = 0
         self._wallbox_pv_gate_open[wallbox_id] = gate_open
         if not gate_open:
             self._wallbox_target_rate_kw[wallbox_id] = 0.0
@@ -2813,6 +2837,13 @@ async def _evaluate_devices(self, data: CoordinatorData) -> None:
         # already covered by the reactive battery_eligible_ids gate, and
         # force_runtime is exempt everywhere).
         cumulative_battery_competing_draw = 0.0
+        # v2.37: predicted draw of every device turned on via the modelled-
+        # surplus path *this cycle that wasn't already on* — subtracted
+        # from the export-meter reading before the next device's turn-on
+        # is corroborated against it, so a single positive meter reading
+        # isn't spent by several devices at once. Already-on devices are
+        # left out: their draw is already reflected in the meter.
+        cumulative_export_committed = 0.0
         now_dt = dt_util.utcnow()
         horizon_end = now_dt + timedelta(hours=data.effective_h_to_solar + BATT_OK_BUFFER_H)
 
@@ -3335,11 +3366,33 @@ async def _evaluate_devices(self, data: CoordinatorData) -> None:
             would_delay_battery_full = not self._battery_would_still_reach_full(
                 data, cumulative_battery_competing_draw + predicted_power
             )
+            # v2.37: while an export sensor is configured and the sun is up,
+            # a device may only be *switched on* via the modelled-surplus
+            # path if the meter also shows a real feed-in that covers its
+            # own draw (minus what devices turned on earlier this cycle
+            # have already claimed from the same reading). The modelled
+            # `remaining_surplus` can read strongly positive for a few
+            # cycles when the wallbox reservation lags a gross-PV upswing,
+            # while almost nothing is actually leaving the house — see
+            # EXPORT_CORROBORATION_MARGIN_KW. Never sheds an already-on
+            # device (its draw is already in the meter reading); only
+            # blocks a fresh turn-on. At night / no export sensor this is
+            # always False.
+            export_uncorroborated = (
+                data.export_sensor_configured
+                and data.battery_full_projection_applies
+                and not is_on
+                and (
+                    data.export_smoothed_kw - cumulative_export_committed
+                    < predicted_power + EXPORT_CORROBORATION_MARGIN_KW
+                )
+            )
             should_on = (
                 force_runtime
                 or (
                     remaining_surplus > predicted_power + SURPLUS_ON_THRESHOLD
                     and not would_delay_battery_full
+                    and not export_uncorroborated
                 )
                 or battery_would_last
             )
@@ -3424,6 +3477,17 @@ async def _evaluate_devices(self, data: CoordinatorData) -> None:
                         f"{predicted_power:.2f} kW benötigt, Akku würde nicht bis Solar-Start reichen)"
                     )
                 await self._log_decision(dev, False, decision_titel, decision_reason)
+            elif export_uncorroborated and remaining_surplus > predicted_power + SURPLUS_ON_THRESHOLD:
+                # Modelled surplus would switch this on, but the meter
+                # doesn't back it up yet — held, not switched, so the log
+                # doesn't read as a plain hysteresis hold.
+                await self._log_decision(
+                    dev, False, "Wartet — keine echte Einspeisung",
+                    f"rechnerischer Überschuss reichte ({remaining_surplus:.2f} kW), aber es "
+                    f"wird nur {max(data.export_smoothed_kw - cumulative_export_committed, 0.0):.2f} "
+                    f"kW wirklich eingespeist ({predicted_power:.2f} kW nötig) — noch nicht "
+                    f"eingeschaltet",
+                )
             else:
                 stable_titel = "Bleibt an — Hysterese" if is_on else "Bleibt aus — Hysterese"
                 decision_reason = (
@@ -3449,6 +3513,13 @@ async def _evaluate_devices(self, data: CoordinatorData) -> None:
                 # what's already been committed ahead of it, not just its
                 # own isolated draw in a vacuum.
                 cumulative_battery_competing_draw += predicted_power
+                # A device turned on this cycle that wasn't already on will
+                # start drawing from real export the moment it switches —
+                # so the next device's export-corroboration check must see
+                # that reduced headroom, not the raw meter reading (which
+                # still reflects a moment before this one came on).
+                if not is_on:
+                    cumulative_export_committed += predicted_power
 
             if should_on and not is_on:
                 # Capped rather than incremented without bound: once

custom_components/surplus_load_switch/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/xchillxx/surplus-load-switch/issues",
   "requirements": [],
-  "version": "2.36.0"
+  "version": "2.37.0"
 }