Keep log, readings and countdowns across restarts (v3.1.3)

- The action log, the last 30 minutes of readings and pending device
  switch countdowns are stored and restored. After a restart the car is
  decided on the first cycle instead of after 10 minutes of fresh
  readings, and the dashboard log keeps its history.
- With a departure less than 2 h away the car is decided even without
  10 minutes of readings (e.g. after a longer outage).
- While the car power sensor has no value (an MQTT sensor right after a
  restart), the draw is estimated from the set current instead of 0 kW,
  which put the car's power into the base load.

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

Author: xchillxx

README.md

@@ -60,6 +60,9 @@ The car is re-planned every 15 minutes on a 30-minute average (or immediately
 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).
+The action log, the readings of the last 30 minutes and running switch
+countdowns survive a Home Assistant restart, so decisions continue right
+away instead of starting from scratch.
 
 ### Validated on recorded data
 

custom_components/surplus_pilot/coordinator.py

@@ -140,6 +140,7 @@ async def device_switch(hass: HomeAssistant, dev: dict, on: bool) -> None:
 
 
 _UNSET = object()
+URGENT_DEPARTURE_H = 2
 
 
 class PilotCoordinator(DataUpdateCoordinator):
@@ -191,10 +192,39 @@ def _changed(event: Event) -> None:
 
     async def async_setup(self) -> None:
         await self.store.async_load()
+        self._restore_runtime_state()
         await self.calibrator.async_load()
         await self._backfill_runtime()
         await self._seed_price_archive()
 
+    def _restore_runtime_state(self) -> None:
+        """Log, recent readings and switch countdowns from before a restart.
+        Readings older than the car's averaging window are dropped, so a long
+        outage still starts fresh."""
+        st = self.store.data
+        self.log.extend(e for e in st["log"][:LOG_LENGTH] if isinstance(e, dict))
+        now = dt_util.now()
+        keep = timedelta(minutes=CAR_AVERAGE_MINUTES + 2)
+        for row in st["samples"]:
+            try:
+                ts = dt_util.parse_datetime(row[0])
+                vals = tuple(float(x) for x in row[1:4])
+            except (TypeError, ValueError, IndexError):
+                continue
+            if ts is not None and timedelta(0) <= now - ts <= keep:
+                self.samples.append((ts, *vals))
+        ids = {d[CONF_DEV_ID] for d in self.devices}
+        for did, (want, since) in st["pending"].items():
+            ts = dt_util.parse_datetime(since) if isinstance(since, str) else None
+            if did in ids and ts is not None and now - ts <= timedelta(hours=1):
+                self._pending[did] = (bool(want), ts)
+
+    def _persist_runtime_state(self) -> None:
+        st = self.store.data
+        st["samples"] = [[s[0].isoformat(), round(s[1], 3), round(s[2], 3), round(s[3], 3)] for s in self.samples]
+        st["pending"] = {did: [want, ts.isoformat()] for did, (want, ts) in self._pending.items()}
+        st["log"] = list(self.log)
+
     async def _seed_price_archive(self) -> None:
         """Fill the price archive from the recorder's hourly statistics of a
         current-price sensor, so the cheap threshold works from day one."""
@@ -295,6 +325,8 @@ def _query():
 
     def _log(self, text: str) -> None:
         self.log.appendleft({"zeit": dt_util.now().strftime("%d.%m. %H:%M"), "text": text})
+        self.store.data["log"] = list(self.log)
+        self.store.save()
 
     @property
     def mode(self) -> str:
@@ -452,10 +484,14 @@ async def _async_update_data(self) -> dict:
         plugged = None
         if self.car_cfg:
             c = self.car_cfg
-            car_kw = power_kw(self.hass, c.get(CONF_CAR_POWER_SENSOR)) or 0.0
+            meas = power_kw(self.hass, c.get(CONF_CAR_POWER_SENSOR))
             ch = is_on(self.hass, c.get(CONF_CAR_CHARGING_SENSOR))
-            charging = bool(ch) if ch is not None else (car_kw > 0.3 or self.car.switch_on())
-            if c.get(CONF_CAR_POWER_SENSOR) is None and charging and c.get(CONF_CAR_CURRENT_ENTITY):
+            charging = bool(ch) if ch is not None else ((meas or 0.0) > 0.3 or self.car.switch_on())
+            car_kw = meas if meas is not None else 0.0
+            # no power reading (none configured, or e.g. an MQTT sensor still
+            # empty after a restart): estimate it from the set current, so the
+            # car's draw doesn't end up in the base load
+            if meas is None and charging and c.get(CONF_CAR_CURRENT_ENTITY):
                 car_kw = (number(self.hass, c[CONF_CAR_CURRENT_ENTITY]) or 0) * self.car.kw_per_a
             plugged = plugged_state(self.hass, c.get(CONF_CAR_PLUGGED_SENSOR))
             if plugged is None:
@@ -558,7 +594,9 @@ def inputs(pv_kw: float, base_kw: float, car_fixed: float | None) -> P.Inputs:
             if forced or replan or slot != self._car_slot:
                 win = [s for s in self.samples if (now - s[0]).total_seconds() <= CAR_AVERAGE_MINUTES * 60]
                 covered = (win[-1][0] - win[0][0]).total_seconds() / 60 if len(win) > 1 else 0
-                if covered >= CAR_MIN_COVERAGE_MINUTES or forced or (replan and win):
+                # a departure within 2 h doesn't wait for 10 min of readings
+                urgent = nd is not None and nd.start - now <= timedelta(hours=URGENT_DEPARTURE_H)
+                if covered >= CAR_MIN_COVERAGE_MINUTES or forced or ((replan or urgent) and win):
                     pv_m = sum(s[1] for s in win) / len(win)
                     base_m = statistics.median(s[2] for s in win)
                     self.car_plan = P.make_plan(inputs(pv_m, base_m, None))
@@ -591,6 +629,8 @@ def inputs(pv_kw: float, base_kw: float, car_fixed: float | None) -> P.Inputs:
             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._persist_runtime_state()
+        self.store.save()
 
         self.status = self._build_status(now, pv, load, base, soc, export, car_in, car_kw, charging, sun,
                                          load_stale, paused)

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.2"
+  "version": "3.1.3"
 }

custom_components/surplus_pilot/store.py

@@ -52,6 +52,11 @@ async def async_load(self) -> None:
         data.setdefault("cheap_percentile", 10)
         data.setdefault("cheap_target", 80)
         data.setdefault("commands", {"date": dt_util.now().date().isoformat(), "count": 0})
+        # survive a restart: action log, the last 30 min of readings (car
+        # decision needs 10 min of them) and running switch countdowns
+        data.setdefault("log", [])
+        data.setdefault("samples", [])
+        data.setdefault("pending", {})
         self.data = data
 
     def save(self) -> None:

tests/test_integration.py

@@ -208,3 +208,47 @@ async def test_new_departure_is_planned_at_once(hass: HomeAssistant, freezer):
     await co.async_refresh()
     assert co.car_plan.need_kwh > 5
     assert co.car.decision.time == dt_util.now()
+
+
+async def test_log_readings_and_countdowns_survive_a_restart(hass: HomeAssistant, freezer):
+    """07.10. live: after each HA restart the action log was empty and the
+    car stayed 'unknown' for 10 min while readings were collected again."""
+    freezer.move_to("2026-10-07 09:01:00+00:00")
+    set_world(hass, pv=9.0, load=0.6, soc=96, car_soc=50, export=2.0)
+    for e in ("switch.car_charge", "switch.miner", "switch.pump", "climate.pool"):
+        hass.states.async_set(e, "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()
+
+    async def fake(call):
+        ent = call.data.get("entity_id")
+        if call.domain == "switch":
+            hass.states.async_set(ent, "on" if call.service == "turn_on" else "off")
+        elif call.domain == "climate":
+            hass.states.async_set(ent, call.data["hvac_mode"])
+        elif call.domain == "number":
+            hass.states.async_set(ent, call.data["value"], {"min": 5, "max": 16})
+
+    for dom, srv in (("switch", "turn_on"), ("switch", "turn_off"), ("number", "set_value"),
+                     ("climate", "set_hvac_mode")):
+        hass.services.async_register(dom, srv, fake)
+    for _ in range(14):
+        freezer.tick(timedelta(minutes=1))
+        set_world(hass, pv=9.0, load=0.6, soc=96, car_soc=50, export=2.0)
+        async_fire_time_changed(hass, dt_util.utcnow())
+        await hass.async_block_till_done()
+    co = hass.data[DOMAIN][entry.entry_id]
+    log_before = list(co.log)
+    assert log_before and co.car.decision is not None
+    pending_before = dict(co._pending)
+
+    assert await hass.config_entries.async_reload(entry.entry_id)   # unload saves, setup loads
+    await hass.async_block_till_done()
+    co = hass.data[DOMAIN][entry.entry_id]
+    assert list(co.log)[: len(log_before)] == log_before
+    assert len(co.samples) >= 14
+    assert co.car.decision is not None        # decided on the first cycle, no 10 min wait
+    for did, (want, since) in pending_before.items():
+        assert co._pending.get(did, (None, None))[1] in (since, None)