Fix device starvation by the car top-up, react to plug-in at once (v3.1.1)

- Car priority "no PV chance tomorrow": tomorrow's forecast is taken at
  face value (it is only about the optional top-up). With x0.7 an ordinary
  25 kWh autumn day counted as "no chance" and the top-up pushed the pool
  pump off. Replay of 30 days: pump +2 h, pool heat pump +2 h, 4 kWh less
  export, same grid use, no departure below target.
- Device plan: the car's top-up is no longer a fixed load. Devices rank
  above it and may claim it; the car follows at its next decision. Before,
  a car started on a sunnier 30-min average kept the boiler off.
- Daytime off reason is "no surplus left" instead of "battery below
  reserve" (the battery path is closed in daylight without export anyway).
- Plug-in / charging changes trigger a cycle immediately: a car that starts
  charging by itself is stopped within seconds instead of after up to a
  minute.

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

Author: xchillxx

README.md

@@ -28,10 +28,13 @@ and splits the surplus in this order:
 3. **Devices** — by priority, each with its own time window, minimum daily
    runtime, battery reserve and dependency (e.g. a pool heat pump that needs
    the pump).
-4. **Car top-up** — whatever is left, up to the car's charge limit.
+4. **Car top-up** — whatever is left, up to the car's charge limit. Between
+   two car decisions a device may claim power the top-up is using; the car
+   follows at its next decision.
    *Exception:* when the car won't get a PV chance tomorrow (it is away during
-   tomorrow's PV window, or the forecast is too weak), it charges **before**
-   the devices today.
+   most of tomorrow's PV window, or tomorrow's forecast — after the base load
+   and half a battery — covers less than half of what the car is missing), it
+   charges **before** the devices today.
 5. The rest is exported.
 
 If the forecast says PV can't reach a departure target, the car charges the
@@ -54,7 +57,8 @@ solar start (+1 h) with all planned loads, and only above each device's
 battery reserve.
 
 The car is re-planned every 15 minutes on a 30-minute average (or immediately
-on plug-in); devices are re-planned every minute on a 5-minute median and
+on plug-in, which is acted on within seconds — a car that starts charging by
+itself is stopped right away); devices are re-planned every minute on a 5-minute median and
 switch only after the decision held for 10 minutes (20 for thermostats).
 
 ### Validated on recorded data

custom_components/surplus_pilot/__init__.py

@@ -17,6 +17,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     entry.async_on_unload(entry.add_update_listener(_reload))
+    unsub = coordinator.async_watch_car()
+    if unsub:
+        entry.async_on_unload(unsub)
     return True
 
 

custom_components/surplus_pilot/coordinator.py

@@ -9,7 +9,8 @@
 from datetime import datetime, time as dtime, timedelta
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.helpers.event import async_track_state_change_event
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
 
@@ -166,6 +167,24 @@ def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
         self.car_plan: P.Plan | None = None
         self.status: dict = {}
 
+    def async_watch_car(self):
+        """Plug-in and charge start run a cycle right away instead of at the
+        next full minute: a car that starts charging by itself is stopped
+        within seconds (the home battery pays for every minute)."""
+        c = self.car_cfg or {}
+        ents = [e for e in (c.get(CONF_CAR_PLUGGED_SENSOR), c.get(CONF_CAR_PLUGGED_FALLBACK),
+                            c.get(CONF_CAR_CHARGING_SENSOR)) if e]
+        if not ents:
+            return None
+
+        @callback
+        def _changed(event: Event) -> None:
+            old, new = event.data.get("old_state"), event.data.get("new_state")
+            if old is not None and new is not None and old.state != new.state:
+                self.hass.async_create_task(self.async_request_refresh())
+
+        return async_track_state_change_event(self.hass, ents, _changed)
+
     async def async_setup(self) -> None:
         await self.store.async_load()
         await self.calibrator.async_load()
@@ -554,7 +573,13 @@ def inputs(pv_kw: float, base_kw: float, car_fixed: float | None) -> P.Inputs:
         pv5 = statistics.median(s[1] for s in win5)
         base5 = statistics.median(s[2] for s in win5)
         car5 = statistics.median(s[3] for s in win5)
-        self.device_plan = P.make_plan(inputs(pv5, base5, car5))
+        car_fixed = car5
+        cp = self.car_plan
+        if cp is not None and not cp.car_first and not cp.car_grid and cp.car_reason != "pflicht_minimum":
+            # the top-up ranks below the devices: they may claim it, the car
+            # follows at its next decision (only the obligation stays fixed)
+            car_fixed = min(car5, cp.car_must_kw)
+        self.device_plan = P.make_plan(inputs(pv5, base5, car_fixed))
         await self._apply_devices(now, dev_on)
 
         self.status = self._build_status(now, pv, load, base, soc, export, car_in, car_kw, charging, sun,

custom_components/surplus_pilot/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "local_polling",
   "issue_tracker": "https://github.com/xchillxx/surplus-pilot/issues",
   "requirements": [],
-  "version": "3.1.0"
+  "version": "3.1.1"
 }

custom_components/surplus_pilot/planner.py

@@ -43,6 +43,7 @@
 PV_HOUR_MARGIN_KW = 1.0        # an hour counts as "PV hour" when forecast > base + 1 kW
 CHEAP_FORECAST_TRUST = 1.0     # optional cheap top-up: trust the forecast fully (no guarantee needed)
 TOMORROW_SHARE = 0.5           # tomorrow must cover this share of the car's missing energy
+TOMORROW_FORECAST_TRUST = 1.0  # the top-up is optional: no extra safety factor (x0.7 put it before the devices too often)
 
 
 @dataclass
@@ -240,7 +241,7 @@ def car_pv_chance_tomorrow(inp: Inputs, car_missing_kwh: float) -> bool:
         return False
     if not inp.forecast:
         return True
-    surplus, _ = forecast_surplus_kwh(inp.forecast, start, end, inp.night_base_kw)
+    surplus, _ = forecast_surplus_kwh(inp.forecast, start, end, inp.night_base_kw, TOMORROW_FORECAST_TRUST)
     if surplus <= 0 and forecast_kwh(inp.forecast, start, end) == 0:
         return True  # no forecast published for tomorrow yet -> don't panic
     battery_missing = 0.0  # battery is usually refilled first tomorrow
@@ -460,7 +461,9 @@ def _devices(inp: Inputs, remaining: float) -> dict[str, DeviceDecision]:
             out[d.id] = DeviceDecision(True, "akku_reicht", "akku")
             planned[d.id] = True
             continue
-        if inp.battery_soc is not None and inp.battery_soc < d.soc_reserve:
+        # name the rule that actually blocked it: in daylight without export
+        # the battery path is closed anyway, the reserve is not the reason
+        if gate and inp.battery_soc is not None and inp.battery_soc < d.soc_reserve:
             reason = "akku_reserve"
         elif day:
             reason = "kein_ueberschuss"

tests/test_integration.py

@@ -142,3 +142,39 @@ async def test_unknown_plug_state_means_not_present(hass: HomeAssistant, freezer
     hass.states.async_set("sensor.car_cable", "disconnected")
     await co.async_refresh()
     assert co.status["auto_da"] is False
+
+
+async def test_plug_in_autostart_stopped_without_waiting_for_the_minute(hass: HomeAssistant, freezer):
+    """06:07 live: plugged in at night, the car started by itself and ran a
+    full minute until the next cycle. A plug/charging change runs a cycle now."""
+    set_world(hass, pv=0.0, load=0.6, soc=60, car_soc=52, plugged="off")
+    hass.states.async_set("switch.car_charge", "off")
+    for e in ("switch.miner", "switch.pump", "climate.pool"):
+        hass.states.async_set(e, "off")
+    data = {**DATA, "car": {**DATA["car"], "charging_sensor": "binary_sensor.car_charging"}}
+    hass.states.async_set("binary_sensor.car_charging", "off")
+    entry = MockConfigEntry(domain=DOMAIN, data=data)
+    entry.add_to_hass(hass)
+    assert await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
+    calls = []
+
+    async def fake(call):
+        calls.append((call.domain, call.service, dict(call.data)))
+        if call.domain == "switch":
+            hass.states.async_set(call.data["entity_id"], "on" if call.service == "turn_on" else "off")
+
+    for dom, srv in (("switch", "turn_on"), ("switch", "turn_off"), ("number", "set_value")):
+        hass.services.async_register(dom, srv, fake)
+    freezer.tick(timedelta(seconds=15))
+    hass.states.async_set("binary_sensor.car_plugged", "on")
+    await hass.async_block_till_done()
+    freezer.tick(timedelta(seconds=15))
+    hass.states.async_set("switch.car_charge", "on")
+    hass.states.async_set("sensor.car_power", 4.0, {"unit_of_measurement": "kW"})
+    hass.states.async_set("binary_sensor.car_charging", "on")
+    await hass.async_block_till_done()
+    freezer.tick(timedelta(seconds=11))   # request_refresh cooldown, still far below the 60 s cycle
+    async_fire_time_changed(hass, dt_util.utcnow())
+    await hass.async_block_till_done()
+    assert ("switch", "turn_off", {"entity_id": "switch.car_charge"}) in calls

tests/test_planner.py

@@ -124,3 +124,30 @@ def test_cheap_topup_only_when_pv_wont_do_it():
     inp.car.soc = 55.0
     plan = P.make_plan(inp)
     assert not plan.car_grid
+
+
+def test_ordinary_autumn_tomorrow_keeps_devices_before_car_topup():
+    """07.10.2026 live: car 52 % (limit 80), tomorrow ~25 kWh forecast, car
+    home all day. The x0.7 forecast made it 'no PV chance tomorrow' and the
+    optional top-up pushed the pool pump off."""
+    now = datetime(2026, 10, 7, 10, 30, tzinfo=TZ)
+    car = P.CarInput(present=True, soc=52.0, limit_soc=80.0, capacity_kwh=72.89, efficiency=0.9, min_kw=4.14,
+                     max_kw=11.04)
+    tomorrow = now.replace(hour=0, minute=0) + timedelta(days=1)
+    kwh = {10: 1.5, 11: 2.8, 12: 3.8, 13: 4.3, 14: 4.3, 15: 3.8, 16: 2.9, 17: 1.6, 18: 0.6}
+    fc = [P.ForecastHour(end=tomorrow + timedelta(hours=h), kwh=v) for h, v in kwh.items()]
+    pump = P.DeviceInput(id="pump", name="Poolpumpe", priority=3, decision_kw=1.34, is_on=True, soc_reserve=85.0)
+    plan = P.make_plan(base_inputs(now, pv_kw=6.0, base_kw=1.0, battery_soc=70.0, battery_capacity_kwh=13.8,
+                                   car=car, forecast=fc, devices=[miner(True), pump]))
+    assert not plan.car_first
+    assert plan.devices["pump"].on
+
+
+def test_daytime_off_reason_is_missing_surplus_not_reserve():
+    now = datetime(2026, 10, 7, 13, 0, tzinfo=TZ)
+    boiler = P.DeviceInput(id="boiler", name="Boiler", priority=5, decision_kw=2.0, is_on=True, soc_reserve=95.0)
+    plan = P.make_plan(base_inputs(now, pv_kw=2.0, base_kw=1.0, battery_soc=83.0, export_kw=0.0, devices=[boiler]))
+    assert plan.devices["boiler"].reason == "kein_ueberschuss"
+    night = now.replace(hour=22)
+    plan = P.make_plan(base_inputs(night, battery_soc=83.0, devices=[boiler]))
+    assert plan.devices["boiler"].reason == "akku_reserve"