@@ -467,19 +467,27 @@ def charger_control_dispatch_active(self, car_n, now):
         The dispatch times on the sensor are judged against the clock rather than its on/off
         state, which only refreshes every couple of minutes and would run the charger on past
         the end of a dispatch. A sensor with no dispatch times falls back to its state.
+
+        While Octopus Smart Control is off the sensor goes on listing the plan Octopus made
+        before, which nothing will act on (#5339), so only the planned dispatches Predbat still
+        uses are followed - a bump charge the user asked for - and the sensor's state, which
+        reflects that plan too, is not fallen back on.
         """
         if not self.get_arg("octopus_intelligent_charging", True):
             return False
         slot = self.charger_control_dispatch_sensor(car_n)
         if not slot:
             return False
+        smart_control_off = self.base.octopus_smart_control_off(car_n, save=False)
         dispatches = []
         for attribute in ("planned_dispatches", "completed_dispatches"):
             value = self.get_state_wrapper(slot, attribute=attribute)
             if isinstance(value, list):
+                if smart_control_off and attribute == "planned_dispatches":
+                    value = self.base.smart_control_off_slots(value, False)
                 dispatches.extend(value)
         if not dispatches:
-            return self.get_state_wrapper(slot) == "on"
+            return not smart_control_off and self.get_state_wrapper(slot) == "on"
         for dispatch in dispatches:
             if not isinstance(dispatch, dict):
                 continue
 
@@ -15,6 +15,7 @@
 
 from tests.test_infra import run_async
 from car_charger_control import CarChargerControl, GUEST_CHARGING_MAX_HOURS, OCTOPUS_DISCOVERY_WAIT_MINUTES, parse_control_setting, parse_dispatch_time
+from fetch import Fetch
 
 LONDON = pytz.timezone("Europe/London")
 
@@ -43,10 +44,19 @@ async def load(self, module, key):
 class FakeBase:
     """The parts of the base object the mixin reads."""
 
+    # Predbat's own filter for the dispatches still used while Octopus Smart Control is off
+    smart_control_off_slots = Fetch.smart_control_off_slots
+
     def __init__(self):
         """Not read only unless a test says so."""
         self.set_read_only = False
         self.num_cars = 1
+        # car_n -> True while that car's Octopus Smart Control switch is off
+        self.smart_control_off = {}
+
+    def octopus_smart_control_off(self, car_n, save=True):
+        """Whether the car's Smart Control switch is off, as Fetch.octopus_smart_control_off."""
+        return self.smart_control_off.get(car_n, False)
 
 
 class FakeCharger:
@@ -577,6 +587,32 @@ def test_dispatch_times_judged_against_the_clock():
     assert component.charger_control_dispatch_active(0, now) is True
 
 
+def test_smart_control_off_ignores_planned_dispatches():
+    """While Octopus Smart Control is off the dispatch sensor keeps the plan Octopus made before, but
+    nothing will act on it (#5339), so the charger does not follow it - only a manual bump charge."""
+    component = _octopus_component(FakeOctopus(), is_charger=False)
+    component.args["octopus_intelligent_charger_follows_car"] = True
+    now = _now()  # 01:30 London, 00:30 UTC
+    smart = {"start": "2026-06-01T00:15:00+0000", "end": "2026-06-01T01:00:00+0000", "source": "smart-charge"}
+    component.sensors[DISPATCH]["state"] = "on"
+    component.sensors[DISPATCH]["planned_dispatches"] = [smart]
+    assert component.charger_control_dispatch_active(0, now) is True
+    component.base.smart_control_off[0] = True
+    assert component.charger_control_dispatch_active(0, now) is False
+    run_async(component.charger_control_tick(now))
+    assert component.commands == [("a", "off", 0)], component.commands
+    # The sensor's state reflects the ignored plan too, so it is not fallen back on
+    component.sensors[DISPATCH]["planned_dispatches"] = []
+    assert component.charger_control_dispatch_active(0, now) is False
+    # A bump charge the user asked for still runs the charger
+    component.sensors[DISPATCH]["planned_dispatches"] = [dict(smart, source="bump-charge")]
+    assert component.charger_control_dispatch_active(0, now) is True
+    # Another car's switch does not count
+    component.base.smart_control_off = {1: True}
+    component.sensors[DISPATCH]["planned_dispatches"] = [smart]
+    assert component.charger_control_dispatch_active(0, now) is True
+
+
 def test_is_charger_that_has_lost_its_value_is_not_a_no():
     """A dispatch sensor reporting is_charger as unknown or unavailable is cannot tell, not 'not the charger'."""
     for lost in ("unknown", "unavailable", "none", ""):
@@ -951,6 +987,7 @@ def run_car_charger_control_tests(my_predbat=None):
     test_octopus_rule_charge_point_releases_a_running_charger()
     test_octopus_rule_car_integrated_follows_the_dispatch_sensor()
     test_dispatch_times_judged_against_the_clock()
+    test_smart_control_off_ignores_planned_dispatches()
     test_is_charger_that_has_lost_its_value_is_not_a_no()
     test_guest_switch_toggle()
     test_octopus_rule_explicit_true_never_overrides_a_charge_point()
 
@@ -609,6 +609,8 @@ On Octopus Intelligent (or E.ON/EDF SmartFlex through the Kraken component), wha
 - **Octopus drives the car** - the car itself is the Intelligent device, so the car starts and stops its own charge. By default Predbat leaves the charger alone, and hands back a charger it was holding as usual, so one it had stopped is started again rather than left stopped. Turn on **switch.predbat_octopus_intelligent_charger_follows_car** (*expert mode*) to have Predbat drive the charger instead: on while a dispatch is running, off otherwise, so the car cannot charge outside the dispatches on its own timers. It follows both its plan and the dispatch times on the car's dispatch sensor, so a new dispatch starts the charger within a few minutes of Octopus announcing it rather than waiting for the next plan, and the charger stops when the dispatch ends.
 - **Predbat cannot tell** - for example the dispatch sensor comes from the Octopus Energy integration, which does not say, or Predbat's Octopus component has not discovered your devices yet. Setting the charger's control setting to `true` tells Predbat your charger is not the Octopus device, so Predbat drives the charger to its plan. If your charger is the Octopus device, leave its control setting off.
 
+Wherever Predbat drives the charger, it also follows the dispatch times on the car's dispatch sensor, as above. While **octopus_intelligent_smart_control** is `off` it does not follow the planned ones, which Octopus will not carry out, apart from bump/boost charges you asked for yourself.
+
 **switch.predbat_octopus_intelligent_charging** only changes Predbat's own planning. With it off, a charger Octopus drives is still left to Octopus - Octopus goes on switching it either way - and a charger for a car Octopus drives follows Predbat's own plan, whether or not **switch.predbat_octopus_intelligent_charger_follows_car** is on.
 
 ### Guest charging