@@ -202,6 +202,7 @@ enph
 enphase
 enphaseenergy
 Enpower
+entityfilter
 entrez
 epod
 epvtoday
 
@@ -727,6 +727,7 @@ def load_component_class(component_info):
             "mqtt_port": {"required": False, "config": "gateway_mqtt_port", "default": 8883},
             "mqtt_token": {"required": True, "secret": True, "config": "gateway_mqtt_token"},
             "gateway_inverter_serial": {"required": False, "config": "gateway_inverter_serial", "default": None},
+            "gateway_display_only": {"required": False, "config": "gateway_display_only", "default": False},
             "gateway_evc_automatic": {"required": False, "config": "gateway_evc_automatic", "default": False},
             "gateway_evc_control": {"required": False, "config": "gateway_evc_control", "default": False},
             "gateway_shared_ct": {"required": False, "config": "gateway_shared_ct", "default": True},
@@ -1039,11 +1040,11 @@ def inverter_source_active(self):
         question rather than a per-inverter one: a component serves whichever inverters it
         discovered, and Inverter only needs to know whether to keep waiting.
         """
-        return any(COMPONENT_LIST.get(name, {}).get("inverter", False) and component for name, component in self.components.items())
+        return any(COMPONENT_LIST.get(name, {}).get("inverter", False) and component and getattr(component, "gateway_display_only", False) is not True for name, component in self.components.items())
 
     def inverter_source_names(self):
         """The display names of every active inverter component, for user-facing messages."""
-        return [COMPONENT_LIST[name]["name"] for name, component in self.components.items() if component and COMPONENT_LIST.get(name, {}).get("inverter", False)]
+        return [COMPONENT_LIST[name]["name"] for name, component in self.components.items() if component and COMPONENT_LIST.get(name, {}).get("inverter", False) and getattr(component, "gateway_display_only", False) is not True]
 
     def inverter_source_status(self):
         """
@@ -1076,6 +1077,8 @@ def inverter_source_status(self):
                 continue
             load_error = self.load_error(name)
             component = self.components.get(name, None)
+            if component and getattr(component, "gateway_display_only", False) is True:
+                continue
             if load_error is not None:
                 state = "failed to start: {}".format(load_error)
             elif not component:
 
@@ -883,6 +883,13 @@
         "type": "switch",
         "default": True,
     },
+    {
+        "name": "octopus_intelligent_charger_follows_car",
+        "friendly_name": "Drive the charger to the Intelligent dispatches when Octopus drives the car",
+        "type": "switch",
+        "default": False,
+        "enable": "expert_mode",
+    },
     {
         "name": "octopus_saving_auto_join",
         "friendly_name": "Octopus Saving Session Auto Join",
 
@@ -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
@@ -62,6 +65,7 @@
 PV_SCENARIO_PV10 = 1
 PV_SCENARIO_PV90 = 2
 LOAD_FORECAST_HISTORY_MAX_DAYS = 30  # Max days of history used by the weighted-bucket load forecast (days_previous_auto)
+LOAD_FORECAST_RECORDED_MIN_MINUTES = 60  # Recorded load needed before its average fills slots no history covers (new installs, batpred#5548)
 CONFIG_ROOTS = ["/config", "/conf", "/homeassistant", "./"]
 TIME_FORMAT_HA = "%Y-%m-%dT%H:%M:%S%z"
 TIME_FORMAT_HA_TZ = "%Y-%m-%dT%H:%M:%S.%f%z"
 
@@ -609,7 +609,11 @@ def execute_plan(self):
                         else:
                             # If there is a previous set charge window, but its more than the set window minutes in the future but we are not close to it then we can leave it enabled for now
                             # saves register writes and avoids turning off the window before the inverter knows it finished
-                            if (inverter.charge_start_time_minutes != inverter.charge_end_time_minutes) and (inverter.charge_start_time_minutes - self.minutes_now) > self.set_window_minutes:
+                            # Only for an inverter with no charge enable switch, where turning the charge off means rewriting the
+                            # window itself (#2993). With a switch it is one write that leaves the times alone, and leaving it on
+                            # arms every other slot the inverter has: on a GivEnergy 3-phase the unused slots, held at 00:00-00:00,
+                            # are live for the first minute of the day and charged from the grid at full rate (#5371)
+                            if (not inverter.inv_has_charge_enable_time) and (inverter.charge_start_time_minutes != inverter.charge_end_time_minutes) and (inverter.charge_start_time_minutes - self.minutes_now) > self.set_window_minutes:
                                 self.log(
                                     "Inverter {} leaving charge window as already set and more than set_window_minutes {} away (now {} charge start time {})".format(
                                         inverter.id, self.set_window_minutes, self.time_abs_str(self.minutes_now), self.time_abs_str(inverter.charge_start_time_minutes)
@@ -790,25 +794,32 @@ def execute_plan(self):
                         # Don't disable discharge during force charge/discharge slots but otherwise turn it off to prevent
                         # from draining the battery
                         if not isExporting:
-                            if inverter.inv_has_timed_pause:
-                                if resetPause:
-                                    inverter.adjust_pause_mode(pause_discharge=True)
-                                    pause_discharge_requested = True
-                                    resetPause = False
+                            # Not while this inverter is actually charging, unless it can pause: the battery is being
+                            # filled from the grid, so it cannot be feeding the car. A discharge rate of 0 adds nothing
+                            # then, and some GivEnergy inverters will not grid-charge at all with it at 0 and the SoC on
+                            # the reserve (#5419); pinning reserve just above a rising SoC costs a write for every 1% of
+                            # the climb (#3899). Both are left to reset below for the duration, and applied once charging
+                            # stops - which is the point the inverter returns to demand and the hold starts to mean
+                            # something. A timed pause is one latched write that blocks only discharge, so it stays on
+                            # through the charge, covering the moments the inverter reaches its target before Predbat
+                            # sees it. The sibling iBoost hold below already sits out a charge for the same reason.
+                            hold_deferred = (not inverter.inv_has_timed_pause) and status_per_inverter.get(inverter.id) == "Charging"
+                            if hold_deferred:
+                                self.log("Inverter {} is charging, so the hold for car {} leaves the discharge rate and reserve alone until charging stops".format(inverter.id, car_n))
                             else:
-                                if discharge_rate is None:
-                                    discharge_rate = 0
-                                # Not while actually charging: the battery is being filled from the grid, so it
-                                # cannot be feeding the car, and pinning reserve just above a rising SoC costs a
-                                # write for every 1% of the climb (#3899). Left to reset below for the duration,
-                                # and latched at the SoC reached once charging stops - which is the point the
-                                # inverter returns to demand and the hold starts to mean something. The sibling
-                                # iBoost hold below already sits out a charge for the same reason.
-                                if self.set_reserve_enable and status != "Charging":
-                                    inverter.adjust_reserve(min(inverter.soc_percent + 1, 100))
-                                    resetReserve = False
+                                if inverter.inv_has_timed_pause:
+                                    if resetPause:
+                                        inverter.adjust_pause_mode(pause_discharge=True)
+                                        pause_discharge_requested = True
+                                        resetPause = False
+                                else:
+                                    if discharge_rate is None:
+                                        discharge_rate = 0
+                                    if self.set_reserve_enable:
+                                        inverter.adjust_reserve(min(inverter.soc_percent + 1, 100))
+                                        resetReserve = False
+                                self.log("Disabling battery discharge whilst car {} is charging".format(car_n))
                             carHolding = True
-                            self.log("Disabling battery discharge whilst car {} is charging".format(car_n))
                             if ("Hold for car" not in status) and (status_hold_car == ""):
                                 if status == "Demand":
                                     status = "Hold for car"
@@ -1235,11 +1246,6 @@ def fetch_inverter_data(self, quick=False):
                 self.charge_window = inverter.charge_window
                 self.export_window = inverter.export_window
                 self.export_limits = inverter.export_limits
-                if not inverter.inv_support_discharge_freeze:
-                    # Force off unsupported feature
-                    self.log("Note: Inverter does not support discharge freeze - disabled")
-                    self.set_export_freeze = False
-                    self.set_export_freeze_only = False
                 if not inverter.inv_support_charge_freeze:
                     # Force off unsupported feature
                     self.log("Note: Inverter does not support charge freeze - disabled")
@@ -1249,6 +1255,14 @@ def fetch_inverter_data(self, quick=False):
                     self.set_reserve_enable = False
                     self.set_reserve_hold = False
                     self.set_discharge_during_charge = True
+            # Fleet-wide like the capability below, and for the same reason: the prediction models one
+            # combined battery, so a single inverter that keeps charging from solar through a Freeze
+            # Export means the plan's hold does not happen (#5082).
+            if not inverter.inv_support_discharge_freeze:
+                # Force off unsupported feature
+                self.log("Note: Inverter {} does not support discharge freeze - disabled".format(inverter.id))
+                self.set_export_freeze = False
+                self.set_export_freeze_only = False
             # Unlike the first-inverter-only settings above this is a fleet-wide capability: the
             # prediction models one combined battery, so a single inverter that just disables
             # charging during Freeze Export means the fleet as a whole cannot recapture PV.