@@ -39,6 +39,9 @@
 # A car_charging_now reading only confirms the half hour it is in (keeping that half hour cheap once the car
 # stops, GH#5316) from this many minutes into it: the sensor can lag a car that stopped just before the boundary
 DYNAMIC_LOAD_CAR_CONFIRM_MINUTES = 2
+# How long a half hour an Octopus Intelligent planned dispatch ran in keeps the dispatch rate after it ends,
+# while waiting for Octopus to list it as a completed dispatch - seen to take 15 to 60 minutes (GH#5520)
+OCTOPUS_DISPATCH_HOLD_MINUTES = 90
 
 # Extra cloud divergence applied to the PV10 scenario on top of the computed cloud factor, so the
 # downside case diverges harder than the central one
 
@@ -1464,6 +1464,9 @@ def fetch_sensor_data(self, save=True):
         # Dynamic load: cancel the Octopus Intelligent slots of a car that is in one but not charging -
         # before the rates are built, so a cancelled dispatch never gets its cheap rate
         dynamic_load_car_changed = self.dynamic_load_car_check(save=save)
+        if save:
+            # Remember the half hour a dispatch is running in, now it is known whether the car was cancelled
+            self.octopus_held_update()
         octopus_surplus_changed = False
 
         if "rates_export_octopus_url" in self.args:
@@ -1806,6 +1809,8 @@ def fetch_sensor_data_cars(self, save=True):
         # Cars whose charging plan came from Octopus Intelligent dispatch slots this cycle - used
         # below to decide which cars get a model-facing charge limit override (#4967)
         iog_slot_cars = []
+        # The planned dispatches each car's plan used this cycle, for octopus_held_update()
+        self.octopus_slots_planned = {}
 
         if entity_id_list:
             # Process each car's intelligent slot configuration
@@ -1857,10 +1862,16 @@ def fetch_sensor_data_cars(self, save=True):
                 # Completed and planned slots - merge from all cars
                 if completed:
                     self.octopus_slots[car_n] += completed
+                planned_used = []
                 if planned and (not self.octopus_intelligent_ignore_unplugged or self.car_charging_planned[car_n] or self.car_charging_now[car_n]):
                     # We only count planned slots if the car is plugged in or we are ignoring unplugged cars. A car
                     # charging now is plugged in, even before car_charging_planned catches up with an ad-hoc dispatch
-                    self.octopus_slots[car_n] += planned
+                    planned_used = planned
+                # The half hours a planned dispatch has already run in, until the completed list has them (#5520).
+                # After the completed list, which is the record once it arrives, and ahead of the planned one
+                self.octopus_slots[car_n] += self.octopus_held_dispatches(car_n, completed or [], planned_used)
+                self.octopus_slots[car_n] += planned_used
+                self.octopus_slots_planned[car_n] = planned_used
 
                 # Extract vehicle data if we can get it
                 size = self.get_state_wrapper(entity_id=entity_id, attribute="vehicle_battery_size_in_kwh")
 
@@ -19,7 +19,7 @@
 import re
 from datetime import datetime, timedelta, timezone
 from predbat_metrics import record_api_call
-from const import TIME_FORMAT, TIME_FORMAT_OCTOPUS, DISPATCH_SOURCE_CHARGER_SCHEDULE, REPEAT_FULL_LOG_SECONDS
+from const import TIME_FORMAT, TIME_FORMAT_OCTOPUS, DISPATCH_SOURCE_CHARGER_SCHEDULE, REPEAT_FULL_LOG_SECONDS, OCTOPUS_DISPATCH_HOLD_MINUTES
 from utils import RepeatLogGate, str2time, minutes_to_time, dp1, dp2, dp4, minute_data, round_out_to_period, filter_payment_method, is_edge_block_body, token_mint_backoff_seconds, TOKEN_MINT_BACKOFF_LOG_INTERVAL_SECONDS
 from component_base import ComponentBase
 from mock_base import MockBase as SharedMockBase
@@ -3258,8 +3258,11 @@ def octopus_slots_signature(self, octopus_slots):
         and force a needless replan each time. For a currently active slot the signature keeps only
         the stable fields (window end, source, location); genuine changes - new/removed slots, a
         moved window end, a revised future slot, a future slot becoming active - still alter it.
+
+        A held slot (octopus_held_dispatches()) is left out: it only re-states a half hour a planned dispatch
+        already priced, and the one for the half hour in progress ends at now, so moves every cycle.
         """
-        return dispatch_slots_signature(octopus_slots, self.now_utc)
+        return dispatch_slots_signature([[slot for slot in car_slots if not slot.get("held", False)] for car_slots in octopus_slots], self.now_utc)
 
     def load_free_slot(self, octopus_free_slots, rate_dict, export=False, rate_replicate=None):
         """
@@ -4056,6 +4059,90 @@ def rate_add_io_slots(self, car_n, rates, octopus_slots):
 
         return rates
 
+    def octopus_planned_running(self, car_n, planned):
+        """
+        The source of the planned dispatch that is pricing the current half hour off-peak for car_n, or None
+        when none is.
+
+        The dispatch must have started - on the exact clock, as the Octopus API component advances the start
+        of a running dispatch to the time of its last poll, which is after minutes_now - and reach into the
+        current half hour, which rate_add_io_slots() prices whole. One still to start is not counted, though
+        its half hour is priced too: Octopus can withdraw it before it runs.
+        """
+        minute_exact = self.dynamic_load_car_minute(self.now_utc_real)
+        for slot in planned:
+            start_minutes, end_minutes, _, source, location = self.decode_octopus_slot(car_n, slot, raw=True)
+            if start_minutes == end_minutes or not self.dispatch_billed_off_peak(source, location, end_minutes):
+                continue
+            if start_minutes <= minute_exact and round_out_to_period(start_minutes, end_minutes)[1] > self.minutes_now:
+                return source
+        return None
+
+    def octopus_held_update(self):
+        """
+        Remember the half hour a planned Octopus Intelligent dispatch is running in, per car, so it keeps the
+        dispatch rate once it has passed (see octopus_held_dispatches()).
+
+        Called once per cycle after dynamic_load_car_check(), so that a half hour in which the car was seen
+        in its dispatch but not charging is not kept - unless it charged earlier in the same half hour,
+        which Octopus bills off-peak whole (see dynamic_load_car_strip_from()). Half hours are kept by their
+        absolute start, as minutes since midnight_utc mean something else after midnight, and dropped
+        OCTOPUS_DISPATCH_HOLD_MINUTES after they end.
+        """
+        period_minute = (self.minutes_now // 30) * 30
+        period_start = self.midnight_utc + timedelta(minutes=period_minute)
+        for car_n in range(self.num_cars):
+            held = self.octopus_slots_held.setdefault(car_n, {})
+            for start in list(held):
+                if start + timedelta(minutes=30 + OCTOPUS_DISPATCH_HOLD_MINUTES) <= self.now_utc:
+                    del held[start]
+            strip_from = self.dynamic_load_car_strip_from(car_n)
+            if strip_from is not None and strip_from < period_minute + 30:
+                held.pop(period_start, None)
+                continue
+            source = self.octopus_planned_running(car_n, self.octopus_slots_planned.get(car_n, []))
+            if source is not None:
+                held[period_start] = source
+
+    def octopus_held_dispatches(self, car_n, completed, planned):
+        """
+        The half hours a planned dispatch of car_n ran in that nothing else covers any more, as dispatches
+        that have finished, to go into octopus_slots with the completed ones.
+
+        A planned dispatch only covers what is still to come: the Octopus API component advances the start
+        of a running one to now (trim_started_dispatch()) and any source drops one that has ended, while
+        Octopus lists it as completed 15 to 60 minutes later. In between the half hour went back to the
+        day rate, and as today's cost is priced from the current rates the day's cost jumped up after each
+        half hour of charging and fell back when the completed dispatch arrived (#5520).
+
+        A half hour is covered from when it was seen running (octopus_held_update()) until a completed
+        dispatch overlaps it - which is then the record, including one of no energy, which is treated as
+        never having happened - or the hold runs out. It is left out while a planned dispatch still reaches
+        it, so it is not counted twice against the daily slot cap. The one in progress ends at now: it has
+        finished, so load_octopus_slots() plans no car charging in it, and rate_add_io_slots() prices the
+        rest of the half hour as Octopus bills it once a dispatch has started in it (GH#5316).
+        """
+        held = self.octopus_slots_held.get(car_n, {})
+        if not held:
+            return []
+        covered = []
+        for slot in list(completed) + list(planned):
+            start_minutes, end_minutes, _, _, _ = self.decode_octopus_slot(car_n, slot, raw=True, boundaries_only=True)
+            if start_minutes != end_minutes:
+                covered.append(round_out_to_period(start_minutes, end_minutes))
+
+        dispatches = []
+        for period_start in sorted(held):
+            period_end = period_start + timedelta(minutes=30)
+            end = min(period_end, self.now_utc)
+            if end <= period_start or period_end + timedelta(minutes=OCTOPUS_DISPATCH_HOLD_MINUTES) <= self.now_utc:
+                continue
+            period_minute = minutes_to_time(period_start, self.midnight_utc)
+            if any(start_minutes < period_minute + 30 and end_minutes > period_minute for start_minutes, end_minutes in covered):
+                continue
+            dispatches.append({"start": period_start.strftime(TIME_FORMAT), "end": end.strftime(TIME_FORMAT), "source": held[period_start], "location": "AT_HOME", "held": True})
+        return dispatches
+
     def in_iog_fixed_window(self, minute):
         """
         Whether minute falls in the fixed 23:30-05:30 Intelligent Go window, cheap by tariff rather than by
 
@@ -571,6 +571,8 @@ def reset(self):
         self.dynamic_load_car_effective = {}
         self.dynamic_load_car_stripped = 0
         self.octopus_surplus = set()
+        self.octopus_slots_planned = {}
+        self.octopus_slots_held = {}
         self.battery_capacity_nominal = False
         self.battery_scaling_auto = False
         self.releases = {}