@@ -858,11 +858,15 @@ def _process_telemetry(self, data):
         self._debug_dump("RX telemetry", status, raw=data)
 
         if len(status.inverters) == 0:
-            return
-
+            if not (self.gateway_inverter_serial and self._discovery):
+                return
+            # With a serial list the discovered inverters are the site whatever the hub reports,
+            # so a status naming none of them is every one of them unread, not nothing to do
+            # (#5471). It is not fresh data though, so it does not count towards being alive.
+        else:
+            self._last_telemetry_time = time.time()
+            self.update_success_timestamp()
         self._last_status = status
-        self._last_telemetry_time = time.time()
-        self.update_success_timestamp()
 
         self._update_discovery(status)
         self._update_integrated_energy(status)
@@ -1127,10 +1131,12 @@ def _update_integrated_energy(self, status):
             "charge": sum(max(inv.battery.power_w, 0) for inv in inverters),
             "discharge": sum(max(-inv.battery.power_w, 0) for inv in inverters),
         }
-        pv_wh = [inv.energy.pv_today_wh for inv in inverters]
+        # By serial and not by slot: auto-config can re-run and change the slots, and a counter
+        # must go on being compared with its own last value
+        pv_wh = {inv.serial: inv.energy.pv_today_wh for inv in inverters}
         # A PV-only inverter's generation is part of the load too. It has no slot, so it is not
         # needed for the site to be complete: one that is away simply adds nothing meanwhile.
-        pv_only_wh = {serial: by_serial[serial].energy.pv_today_wh for serial in self._pv_only_serials if serial in by_serial and by_serial[serial].energy.ByteSize() > 0}
+        pv_wh.update({serial: by_serial[serial].energy.pv_today_wh for serial in self._pv_only_serials if serial in by_serial and by_serial[serial].energy.ByteSize() > 0})
 
         state = self._integrated_energy
         if state is None:
@@ -1151,20 +1157,19 @@ def _update_integrated_energy(self, status):
                 today_share = min(max((now - midnight) / (now - previous), 0.0), 1.0)
 
         if previous is None:
-            state["pv"] = [{"base": wh, "high": None, "high_time": 0} for wh in pv_wh]
-            state["pv_only"] = {serial: {"base": wh, "high": None, "high_time": 0} for serial, wh in pv_only_wh.items()}
+            state["pv"] = {serial: {"base": wh, "high": None, "high_time": 0} for serial, wh in pv_wh.items()}
         else:
             elapsed = now - previous
             hours = elapsed / 3600.0
             # Per inverter, so one counter dropping a sample does not hide the others' generation
             pv_rise_limit_wh = GATEWAY_INTEGRATE_MAX_PV_W * hours + GATEWAY_INTEGRATE_PV_STEP_WH
-            pv_rise_wh = sum(self._pv_counter_rise(track, wh, now, pv_rise_limit_wh) for track, wh in zip(state["pv"], pv_wh))
-            pv_only_tracks = state.setdefault("pv_only", {})
-            for serial, wh in pv_only_wh.items():
-                if serial in pv_only_tracks:
-                    pv_rise_wh += self._pv_counter_rise(pv_only_tracks[serial], wh, now, pv_rise_limit_wh)
+            pv_rise_wh = 0.0
+            for serial, wh in pv_wh.items():
+                if serial in state["pv"]:
+                    pv_rise_wh += self._pv_counter_rise(state["pv"][serial], wh, now, pv_rise_limit_wh)
                 else:
-                    pv_only_tracks[serial] = {"base": wh, "high": None, "high_time": 0}
+                    # First seen since the integration began: counted from here on
+                    state["pv"][serial] = {"base": wh, "high": None, "high_time": 0}
             if elapsed <= GATEWAY_INTEGRATE_MAX_GAP_SECONDS:
                 energy = {name: (state["power"][name] + power[name]) / 2.0 * hours * today_share for name in power}
                 for name in energy:
@@ -1796,10 +1801,6 @@ def automatic_config(self):
         status = self._last_status
         all_inverters = list(status.inverters)
 
-        if not all_inverters:
-            self.log("Error: GatewayMQTT: no inverters in gateway status")
-            return
-
         # With gateway_inverter_serial set, a listed inverter the hub has reported before is
         # part of the site even when this status leaves it out (#5471). The records are brought
         # up to date here as well as in _process_telemetry(), for a caller that comes straight here.
@@ -1809,6 +1810,10 @@ def automatic_config(self):
         if serial_set:
             all_inverters += [self._stored_unit(record) for key, record in sorted(self._discovery.items()) if key not in reported]
 
+        if not all_inverters:
+            self.log("Error: GatewayMQTT: no inverters in gateway status")
+            return
+
         # Classify discovered units and route control per GivTCP / GE-Cloud. Neither a
         # GivEnergy Gateway (INVERTER_TYPE_GIVENERGY_GATEWAY) nor a Plant EMS
         # (INVERTER_TYPE_GIVENERGY_EMS) is itself a battery inverter — they are
 
@@ -3684,6 +3684,72 @@ def test_stored_inverter_unread_at_startup_is_still_bound(self):
             assert self._logged(gw, "Error", "CE2225G400", "not being read"), second
             assert gw.non_fatal_error_occurred.call_count == 1, second
 
+    def _empty_status(self):
+        """A status in which the hub names no inverter at all."""
+        status = pb.GatewayStatus()
+        status.device_id = "pbgw_two_ac"
+        status.firmware = "1.0.34"
+        status.schema_version = 1
+        return status
+
+    def test_stored_inverter_is_bound_when_the_hub_reports_no_inverters_at_startup(self):
+        """A single listed inverter with a stored record keeps its slot when the first status names no inverter."""
+        gw = self._listed_gateway(["CE2225G400"], stored=self._STORED_400)
+
+        gw._process_telemetry(self._empty_status().SerializeToString())
+
+        assert gw._auto_configured is True
+        assert gw._args["num_inverters"] == 1
+        assert gw._inverter_slot_serials == ["CE2225G400"]
+        assert gw._states["sensor.predbat_gateway_25g400_soc"] == 0
+        assert gw._states["sensor.predbat_gateway_25g400_battery_capacity"] == 9.5
+        assert self._logged(gw, "Error", "CE2225G400", "not being read")
+        assert gw.non_fatal_error_occurred.call_count == 1
+        # Nothing was read, so the status does not count towards the hub being alive
+        gw.update_success_timestamp.assert_not_called()
+
+    def test_status_with_no_inverters_leaves_configured_inverters_unread(self):
+        """Once configured, a status naming no inverter zeroes the powers, keeps the rest and is an error."""
+        gw = self._listed_gateway(["CE2223G800", "CE2225G400"])
+        healthy = self._two_ac_status("ok")
+        for inv in healthy.inverters:
+            inv.battery.power_w = -3000
+        gw._process_telemetry(healthy.SerializeToString())
+        assert gw._states["sensor.predbat_gateway_23g800_battery_power"] == 3000
+        assert self._errors(gw) == []
+
+        gw._process_telemetry(self._empty_status().SerializeToString())
+
+        assert gw._args["num_inverters"] == 2
+        for suffix in ("23g800", "25g400"):
+            assert gw._states[f"sensor.predbat_gateway_{suffix}_battery_power"] == 0, suffix
+            assert gw._states[f"sensor.predbat_gateway_{suffix}_soc"] == 50, suffix
+        assert self._logged(gw, "Error", "CE2223G800", "CE2225G400", "not being read")
+        assert gw.non_fatal_error_occurred.call_count == 1
+
+        gw._process_telemetry(healthy.SerializeToString())
+        assert gw._states["sensor.predbat_gateway_23g800_battery_power"] == 3000
+        assert self._logged(gw, "Info", "every configured inverter is being read by the hub again")
+
+    def test_status_with_no_inverters_is_ignored_without_a_list_or_a_record(self):
+        """With no serial list, or no inverter discovered yet, a status naming no inverter is ignored as before."""
+        for listed, stored in (([], None), (["CE2225G400"], None)):
+            gw = self._listed_gateway(listed, stored=stored)
+
+            gw._process_telemetry(self._empty_status().SerializeToString())
+
+            assert gw._last_status is None, listed
+            assert gw._auto_configured is False, listed
+            assert gw._args == {}, listed
+
+        # No list: inverters come and go, so one that goes is not held on to
+        gw = self._listed_gateway([])
+        gw._process_telemetry(self._two_ac_status("ok").SerializeToString())
+        healthy = gw._last_status
+        gw._process_telemetry(self._empty_status().SerializeToString())
+        assert gw._last_status is healthy
+        assert self._errors(gw) == []
+
     def test_changed_serial_list_wins_over_stored_discovery(self):
         """A stored record for a serial no longer in the list is not used: the list is the setting."""
         gw = self._listed_gateway(["CE2223G800"], stored=self._STORED_400)
@@ -6927,6 +6993,63 @@ def status(timestamp, pv_only_wh, with_pv_only=True):
         self._feed(gw, status(self.BASE_TIME + 1800, 3500))
         assert approx_equal(gw._integrated_energy["load_wh"], 500.0)
 
+    def test_pv_only_inverter_promoted_to_a_slot_keeps_its_generation(self):
+        """Auto-config re-running and changing the slots does not lose or mix up any inverter's generation."""
+        gw = self._make_gateway()
+        # The PV-only inverter sorts first, so once it has a slot every slot index moves
+        gw.gateway_inverter_serial = ["AA0000P001", "CE2223G800"]
+
+        def status(timestamp, pv_only_wh, has_battery=False):
+            built = self._status(timestamp, grid_w=0, battery_w=(0,), pv_today_wh=1000, serials=("CE2223G800",))
+            inv = built.inverters.add()
+            inv.type = pb.INVERTER_TYPE_GIVENERGY
+            inv.serial = "AA0000P001"
+            inv.primary = True
+            inv.connected = True
+            inv.pv.power_w = 1000
+            inv.energy.pv_today_wh = pv_only_wh
+            if has_battery:
+                inv.battery.soc_percent = 40
+                inv.battery.capacity_wh = 5000
+            return built
+
+        self._feed(gw, status(self.BASE_TIME, 3000))
+        self._feed(gw, status(self.BASE_TIME + 600, 3200))
+        assert gw._pv_only_serials == ("AA0000P001",)
+        assert approx_equal(gw._integrated_energy["load_wh"], 200.0)
+
+        # Its battery readings arrive: _process_telemetry integrates, then re-runs auto-config
+        self._feed(gw, status(self.BASE_TIME + 1200, 3300, has_battery=True))
+        gw.automatic_config()
+        assert gw._inverter_slot_serials == ["AA0000P001", "CE2223G800"]
+        assert gw._pv_only_serials == ()
+        assert approx_equal(gw._integrated_energy["load_wh"], 300.0)
+
+        self._feed(gw, status(self.BASE_TIME + 1800, 3500, has_battery=True))
+        assert approx_equal(gw._integrated_energy["load_wh"], 500.0)
+
+    def test_inverter_given_a_slot_later_has_its_generation_counted_from_then(self):
+        """An inverter that joins the slots after the integration began is counted from its first status, not left out."""
+        gw = self._make_gateway()
+        self._feed(gw, self._status(self.BASE_TIME, grid_w=0, battery_w=(0,), pv_today_wh=1000, serials=("CE2225G400",)))
+        self._feed(gw, self._status(self.BASE_TIME + 600, grid_w=0, battery_w=(0,), pv_today_wh=1100, serials=("CE2225G400",)))
+        assert approx_equal(gw._integrated_energy["load_wh"], 100.0)
+
+        def both(timestamp, first_wh, second_wh):
+            built = self._status(timestamp, grid_w=0, battery_w=(0, 0), pv_today_wh=first_wh)
+            built.inverters[1].energy.pv_today_wh = second_wh
+            return built
+
+        # CE2223G800 appears and takes slot 0; its counter already stands at 7000
+        gw._last_status = both(self.BASE_TIME + 1200, 7000, 1200)
+        gw.automatic_config()
+        assert gw._inverter_slot_serials == ["CE2223G800", "CE2225G400"]
+
+        self._feed(gw, both(self.BASE_TIME + 1200, 7000, 1200))
+        assert approx_equal(gw._integrated_energy["load_wh"], 200.0)
+        self._feed(gw, both(self.BASE_TIME + 1800, 7300, 1250))
+        assert approx_equal(gw._integrated_energy["load_wh"], 550.0)
+
     def test_import_and_load_are_integrated_from_power(self):
         """6 kW of import for 6 minutes is 0.6 kWh; 3 kW of that went into a battery, so load is 0.3 kWh."""
         gw = self._make_gateway()