@@ -583,28 +583,39 @@ def dynamic_load_car_target(self, car_n, minute, now, record=True):
     def dynamic_load_car_state(self):
         """
         The dispatch-check state worth keeping across a restart, in a form storage can hold, keyed by car:
-        - confirmed: the end of the half hour the car was last seen charging in (dynamic_load_car_strip_from());
+        - confirmed: the end of the half hour the car was last seen charging in (dynamic_load_car_strip_from()),
+          while that half hour is still to come;
         - run: the dispatch the car is in, with the earliest start seen for it - the start band is timed from it;
-        - since: when the car was first seen not charging in it - the grace period is timed from it;
         - cancelled: the decision so far, which stands while there is no evidence either way.
 
-        All times are absolute, as minutes since midnight_utc mean something else after midnight. The rest
-        of the state (which cars have a sensor, what has been warned about, this cycle's decision) is
-        rebuilt every cycle.
+        All times are absolute, as minutes since midnight_utc mean something else after midnight. The "not
+        charging since" clock is deliberately not kept: a restart is a stretch with no evidence, after which
+        the running check starts the grace period afresh too (see dynamic_load_car_target()) - the car may
+        have charged in it - and the clock changes with every flap of an unreliable sensor, which would
+        rewrite the store every 15 seconds. The rest (which cars have a sensor, what has been warned about,
+        this cycle's decision) is rebuilt every cycle.
         """
+        now_minute = self.dynamic_load_car_minute(self.now_utc_real)
+        confirmed_cars = {car_n: confirmed for car_n, confirmed in self.dynamic_load_car_confirmed.items() if self.dynamic_load_car_minutes_of(confirmed) > now_minute}
         cars = {}
-        for car_n in sorted(set(self.dynamic_load_car_confirmed) | set(self.dynamic_load_car_since) | set(self.dynamic_load_car_run)):
-            confirmed = self.dynamic_load_car_confirmed.get(car_n)
-            since = self.dynamic_load_car_since.get(car_n)
+        for car_n in sorted(set(confirmed_cars) | set(self.dynamic_load_car_run)):
+            confirmed = confirmed_cars.get(car_n)
             run = self.dynamic_load_car_run.get(car_n)
             cars[str(car_n)] = {
                 "confirmed": confirmed.isoformat() if confirmed else None,
-                "since": since.isoformat() if since else None,
                 "run": {key: (self.midnight_utc + timedelta(minutes=run[key])).isoformat() for key in ("start", "end")} if run else None,
                 "cancelled": bool(self.dynamic_load_car_cancelled.get(car_n, False)),
             }
         return cars
 
+    def dynamic_load_car_minutes_of(self, when):
+        """
+        A time saved by the dispatch check as minutes since midnight_utc, the axis of dynamic_load_car_minute():
+        the times are built from that axis, so it includes clock_skew and must be compared on it, not with
+        now_utc_real.
+        """
+        return (when - self.midnight_utc).total_seconds() / 60
+
     def dynamic_load_car_save(self):
         """
         Save the dispatch-check state (see dynamic_load_car_state()) to storage when it has changed since
@@ -635,9 +646,9 @@ def dynamic_load_car_load(self):
         """
         Restore the dispatch-check state saved by dynamic_load_car_save(), at start up.
 
-        Only what is still current is taken: a confirmed half hour that has not ended yet, and the run,
-        grace clock and decision of a dispatch that has not ended yet. Anything older belongs to a dispatch
-        the car has since left, where the running check would have dropped it too.
+        Only what is still current is taken: a confirmed half hour that has not ended yet, and the run and
+        decision of a dispatch that has not ended yet. Anything older belongs to a dispatch the car has since
+        left, where the running check would have dropped it too.
         """
         storage = self.components.get_component("storage") if self.components else None
         if not storage or self.midnight_utc is None:
@@ -653,27 +664,23 @@ def dynamic_load_car_load(self):
         if not isinstance(cars, dict):
             return
 
-        now = self.now_utc_real
+        now_minute = self.dynamic_load_car_minute(self.now_utc_real)
         restored = []
         for key, car in cars.items():
             try:
                 car_n = int(key)
                 confirmed = datetime.fromisoformat(car["confirmed"]) if car.get("confirmed") else None
-                since = datetime.fromisoformat(car["since"]) if car.get("since") else None
-                run = {name: datetime.fromisoformat(car["run"][name]) for name in ("start", "end")} if car.get("run") else None
-                confirmed_current = confirmed is not None and confirmed > now
-                run_current = run is not None and run["end"] > now
-                run_minutes = {name: (run[name] - self.midnight_utc).total_seconds() / 60 for name in ("start", "end")} if run_current else None
+                run = {name: self.dynamic_load_car_minutes_of(datetime.fromisoformat(car["run"][name])) for name in ("start", "end")} if car.get("run") else None
+                confirmed_current = confirmed is not None and self.dynamic_load_car_minutes_of(confirmed) > now_minute
+                run_current = run is not None and run["end"] > now_minute
             except (ValueError, TypeError, KeyError, AttributeError):
                 continue
             if confirmed_current:
                 self.dynamic_load_car_confirmed[car_n] = confirmed
             if run_current:
                 # Whole minutes stay ints, as the slots they are compared with are
-                self.dynamic_load_car_run[car_n] = {name: int(value) if value == int(value) else value for name, value in run_minutes.items()}
+                self.dynamic_load_car_run[car_n] = {name: int(value) if value == int(value) else value for name, value in run.items()}
                 self.dynamic_load_car_cancelled[car_n] = bool(car.get("cancelled", False))
-                if since is not None:
-                    self.dynamic_load_car_since[car_n] = since
             if confirmed_current or run_current:
                 restored.append(car_n)
         if restored:
 
@@ -25,8 +25,7 @@
 import tempfile
 from datetime import timedelta
 
-from tests.test_infra import run_async
-from tests.test_plan_persistence import _MockComponents, _make_storage
+from tests.test_infra import run_async, MockStorageComponents, make_test_storage
 
 TIME_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
 SENSOR = "binary_sensor.car_charging_now_test"
@@ -1105,14 +1104,14 @@ def _restart(my_predbat):
 def _run_persistence(my_predbat):
     """
     The dispatch-check state is saved to storage whenever it changes and restored after a restart, so a
-    restart part-way through a dispatch neither loses the kept half hour (GH#5316) nor restarts the grace
-    period, the start band or the cancellation.
+    restart part-way through a dispatch neither loses the kept half hour (GH#5316) nor restarts the start
+    band or the cancellation. The grace period does start again, as after any stretch with no evidence.
     """
     failed = False
     saved_components = my_predbat.components
     tmpdir = tempfile.mkdtemp()
     try:
-        storage = _make_storage(my_predbat, tmpdir)
+        storage = make_test_storage(my_predbat, tmpdir)
         saves = []
         backend_save = storage.backend.save
 
@@ -1124,9 +1123,9 @@ async def counting_save(module, filename, data, **kwargs):
         storage.backend.save = counting_save
         slots = [{"start": 390, "end": 450, "kwh": 3.0, "octopus": True}]
 
-        print("Test 49: the confirmed half hour, the grace clock and the dispatch run survive a restart")
+        print("Test 49: the confirmed half hour and the dispatch run survive a restart, the grace clock starts again")
         _reset(my_predbat)
-        my_predbat.components = _MockComponents(storage)
+        my_predbat.components = MockStorageComponents(storage)
         _sensor(my_predbat, "on")
         _cycle(my_predbat, 395, slots=slots)
         _sensor(my_predbat, "off")
@@ -1136,29 +1135,38 @@ async def counting_save(module, filename, data, **kwargs):
         _at(my_predbat, 403)
         _restart(my_predbat)
         failed |= _check("t49 confirmed restored", my_predbat.dynamic_load_car_confirmed.get(0) == my_predbat.midnight_utc + timedelta(minutes=420), "confirmed {}".format(my_predbat.dynamic_load_car_confirmed))
-        failed |= _check("t49 grace clock restored", my_predbat.dynamic_load_car_since.get(0) == since, "since {}".format(my_predbat.dynamic_load_car_since))
+        failed |= _check("t49 grace clock not restored", my_predbat.dynamic_load_car_since.get(0) is None, "since {}".format(my_predbat.dynamic_load_car_since))
         failed |= _check("t49 run restored", my_predbat.dynamic_load_car_run.get(0) == {"start": 390, "end": 450}, "run {}".format(my_predbat.dynamic_load_car_run))
         failed |= _check("t49 still trusted", my_predbat.dynamic_load_car_cancelled.get(0) is False, "cancelled {}".format(my_predbat.dynamic_load_car_cancelled))
-        # The grace runs from the restored clock, not from the restart
+        # The car may have charged while Predbat was down, so the grace runs from the first reading after the restart
         changed = _cycle(my_predbat, 404, 30, slots=slots)
-        failed |= _check("t49 cancelled on the restored clock", changed and my_predbat.dynamic_load_car_cancelled.get(0), "changed {}".format(changed))
+        failed |= _check("t49 not cancelled on the old clock", not changed and not my_predbat.dynamic_load_car_cancelled.get(0), "changed {}".format(changed))
+        changed = _cycle(my_predbat, 406, 30, slots=slots)
+        failed |= _check("t49 cancelled after a fresh grace", changed and my_predbat.dynamic_load_car_cancelled.get(0), "changed {}".format(changed))
         failed |= _check("t49 strip from 07:00", my_predbat.dynamic_load_car_strip_from(0) == 420, "strip from {}".format(my_predbat.dynamic_load_car_strip_from(0)))
 
         print("Test 50: a cancellation survives a restart, with no evidence either way after it")
         _sensor(my_predbat, "unavailable")
-        _at(my_predbat, 406)
+        _at(my_predbat, 407)
         _restart(my_predbat)
         failed |= _check("t50 cancelled restored", my_predbat.dynamic_load_car_cancelled.get(0) is True, "cancelled {}".format(my_predbat.dynamic_load_car_cancelled))
-        _cycle(my_predbat, 407, slots=slots)
+        _cycle(my_predbat, 408, slots=slots)
         failed |= _check("t50 still cancelled", my_predbat.dynamic_load_car_cancelled.get(0) and _kwh(my_predbat) == [0], "kwh {}".format(_kwh(my_predbat)))
 
-        print("Test 51: state is only written when it changes")
+        print("Test 51: state is only written when it changes - not for a sensor flapping between unavailable and off")
         count = len(saves)
-        _cycle(my_predbat, 408, slots=slots)
+        _cycle(my_predbat, 409, slots=slots)
         my_predbat.dynamic_load_car_poll(my_predbat.now_utc_real)
         failed |= _check("t51 no write when unchanged", len(saves) == count, "saves {} was {}".format(len(saves), count))
+        for step, state in enumerate(["off", "unavailable", "off", "unavailable"]):
+            _sensor(my_predbat, state)
+            my_predbat.dynamic_load_car_poll(my_predbat.midnight_utc + timedelta(minutes=409, seconds=15 * (step + 1)))
+        failed |= _check("t51 no write for a flapping sensor", len(saves) == count, "saves {} was {}".format(len(saves), count))
 
-        print("Test 52: state from a dispatch that is over is not restored")
+        print("Test 52: state from a dispatch that is over is not restored, and a confirmation is not kept once its half hour is over")
+        _cycle(my_predbat, 425, slots=slots)
+        saved = run_async(storage.load("predbat", "dynamic_load_car"))
+        failed |= _check("t52 expired confirmation not saved", saved["cars"]["0"]["confirmed"] is None and saved["cars"]["0"]["run"] is not None, "saved {}".format(saved))
         _at(my_predbat, 455)
         _restart(my_predbat)
         failed |= _check(
@@ -1167,22 +1175,42 @@ async def counting_save(module, filename, data, **kwargs):
             "confirmed {} cancelled {} run {}".format(my_predbat.dynamic_load_car_confirmed, my_predbat.dynamic_load_car_cancelled, my_predbat.dynamic_load_car_run),
         )
 
-        print("Test 53: a comparison run, a car with no dispatch and a missing or broken store write and restore nothing")
+        print("Test 53: what is still current is judged on the clock_skew clock the times were recorded on")
+        saved_skew = my_predbat.args.get("clock_skew", None)
+        try:
+            _reset(my_predbat)
+            my_predbat.components = MockStorageComponents(storage)
+            _sensor(my_predbat, "on")
+            # With the clock 5 minutes fast, 06:52 real is 06:57 on the plan's clock
+            my_predbat.args["clock_skew"] = 5
+            _cycle(my_predbat, 387, slots=slots)
+            failed |= _check("t53 confirmed 06:30-07:00 on the skewed clock", my_predbat.dynamic_load_car_confirmed.get(0) == my_predbat.midnight_utc + timedelta(minutes=420), "confirmed {}".format(my_predbat.dynamic_load_car_confirmed))
+            # Real 06:57 is 07:02 on the plan's clock: that half hour is over
+            _at(my_predbat, 417)
+            _restart(my_predbat)
+            failed |= _check("t53 over on the skewed clock is not restored", my_predbat.dynamic_load_car_confirmed.get(0) is None, "confirmed {}".format(my_predbat.dynamic_load_car_confirmed))
+        finally:
+            if saved_skew is None:
+                my_predbat.args.pop("clock_skew", None)
+            else:
+                my_predbat.args["clock_skew"] = saved_skew
+
+        print("Test 54: a comparison run, a car with no dispatch and a missing or broken store write and restore nothing")
         tmpdir2 = tempfile.mkdtemp()
         try:
-            storage2 = _make_storage(my_predbat, tmpdir2)
+            storage2 = make_test_storage(my_predbat, tmpdir2)
             _reset(my_predbat)
-            my_predbat.components = _MockComponents(storage2)
+            my_predbat.components = MockStorageComponents(storage2)
             _sensor(my_predbat, "on")
             _cycle(my_predbat, 395, slots=slots, save=False)
             _cycle(my_predbat, 395, slots=[])
-            failed |= _check("t53 nothing written", run_async(storage2.load("predbat", "dynamic_load_car")) is None)
+            failed |= _check("t54 nothing written", run_async(storage2.load("predbat", "dynamic_load_car")) is None)
             run_async(storage2.save("predbat", "dynamic_load_car", ["not", "a", "dict"], format="json"))
             _restart(my_predbat)
             run_async(storage2.save("predbat", "dynamic_load_car", {"cars": {"x": 1, "0": {"confirmed": "junk", "run": {"start": "junk"}}}}, format="json"))
             _restart(my_predbat)
-            failed |= _check("t53 junk ignored", not my_predbat.dynamic_load_car_confirmed and not my_predbat.dynamic_load_car_run, "confirmed {} run {}".format(my_predbat.dynamic_load_car_confirmed, my_predbat.dynamic_load_car_run))
-            for components in (None, _MockComponents(None)):
+            failed |= _check("t54 junk ignored", not my_predbat.dynamic_load_car_confirmed and not my_predbat.dynamic_load_car_run, "confirmed {} run {}".format(my_predbat.dynamic_load_car_confirmed, my_predbat.dynamic_load_car_run))
+            for components in (None, MockStorageComponents(None)):
                 my_predbat.components = components
                 _cycle(my_predbat, 395, slots=slots)
                 _restart(my_predbat)
 
@@ -50,6 +50,32 @@ def run_async(coro):
     return loop.run_until_complete(coro)
 
 
+class MockStorageComponents:
+    """
+    Minimal components mock returning a pre-configured storage component, for tests of code that saves
+    and loads through Storage.
+    """
+
+    def __init__(self, storage):
+        """Initialise with a storage instance (may be None to simulate unavailable)."""
+        self._storage = storage
+
+    def get_component(self, name):
+        """Return the mocked storage for 'storage', None for everything else."""
+        if name == "storage":
+            return self._storage
+        return None
+
+
+def make_test_storage(predbat, tmpdir):
+    """Create a StorageComponent backed by a real local-file backend in tmpdir."""
+    from storage import StorageComponent, StorageLocalFiles
+
+    storage = StorageComponent(predbat)
+    storage.backend = StorageLocalFiles(tmpdir, predbat.log)
+    return storage
+
+
 def create_aiohttp_mock_response(status=200, json_data=None, json_exception=None):
     """Create a mock aiohttp response object"""
     mock_response = MagicMock()