@@ -108,6 +108,8 @@ def _serial_suffix(serial):
 GATEWAY_COORDINATOR_TYPES = (pb.INVERTER_TYPE_GIVENERGY_EMS, pb.INVERTER_TYPE_GIVENERGY_GATEWAY)
 # Where the discovery record of each inverter in gateway_inverter_serial is kept (see _update_discovery)
 GATEWAY_STORAGE_MODULE = "gateway"
+# How long a failed save of the discovery records waits before it is tried again
+GATEWAY_DISCOVERY_SAVE_RETRY_SECONDS = 5 * 60
 
 # Entity attribute table — keyed by the semantic suffix used in dashboard_item calls
 GATEWAY_ATTRIBUTE_TABLE = {
@@ -233,6 +235,7 @@ class GatewayMQTT(ComponentBase):
     _unavailable_inverters = ((), ())
     _discovery = {}  # replaced, never changed in place, so this default is not shared state
     _discovery_dirty = False
+    _discovery_save_retry_at = 0
     _pv_only_serials = ()
     _inverter_slot_serials = ()
     gateway_device_id = None
@@ -342,6 +345,7 @@ def initialize(self, gateway_device_id=None, mqtt_host=None, mqtt_port=8883, mqt
         self._pv_only_serials = ()  # listed inverters with no battery: counted for PV, never written to
         self._discovery = {}  # upper-case serial -> what the hub last reported it to be, for gateway_inverter_serial
         self._discovery_dirty = False
+        self._discovery_save_retry_at = 0
         self._unavailable_inverters = ((), ())
         self._configured_ev_chargers = frozenset()  # EV charge point ids registered at the last auto-config
         self._last_published_plan = None
@@ -860,6 +864,11 @@ def _process_telemetry(self, data):
 
         if self._needs_reconfigure(status):
             self.automatic_config()
+            if self._auto_configured:
+                # The injection above ran before this status's inverters were bound, so one that
+                # is only published once bound has no entities yet. Publish again before the API
+                # is declared started below.
+                self._inject_entities(status)
         self._check_configured_inverters(status)
 
         # Declare the API started only once auto-config has wired up the inverter args.
@@ -1473,15 +1482,30 @@ async def _load_discovery(self):
             self.log(f"Info: GatewayMQTT: loaded stored discovery for inverter(s) {sorted(loaded)}")
 
     async def _save_discovery(self):
-        """Save the discovery records when they have changed."""
+        """Save the discovery records when they have changed.
+
+        A save that fails stays pending and is tried again after
+        GATEWAY_DISCOVERY_SAVE_RETRY_SECONDS: without the stored record a configured
+        inverter the hub cannot read would be left out after the next restart.
+        """
         storage = self.storage
-        if not self._discovery_dirty or storage is None:
+        if not self._discovery_dirty or storage is None or _monotonic() < self._discovery_save_retry_at:
             return
+        # Cleared before the save so a record that changes while it is being written is saved again
         self._discovery_dirty = False
         try:
-            await storage.save(GATEWAY_STORAGE_MODULE, self._discovery_filename(), {"inverters": self._discovery}, format="json")
+            saved = await storage.save(GATEWAY_STORAGE_MODULE, self._discovery_filename(), {"inverters": self._discovery}, format="json")
         except Exception as e:
             self.log(f"Warn: GatewayMQTT: failed to save inverter discovery: {e}")
+            saved = False
+        else:
+            if not saved:
+                self.log("Warn: GatewayMQTT: failed to save inverter discovery, will retry")
+        if saved:
+            self._discovery_save_retry_at = 0
+        else:
+            self._discovery_dirty = True
+            self._discovery_save_retry_at = _monotonic() + GATEWAY_DISCOVERY_SAVE_RETRY_SECONDS
 
     @staticmethod
     def _stored_unit(record):
@@ -1866,7 +1890,6 @@ def automatic_config(self):
         # Register the gateway's OCPP EV charger as a PredBat car (opt-in). Done after the
         # inverter config so a failure here never blocks battery control.
         self._register_ev_car(status)
-        self._inject_unreported_inverters(status)
 
         self._auto_configured = True
         self._configured_inverter_serials = self._usable_serials(status) | frozenset(self._inverter_slot_serials)
 
@@ -3720,6 +3720,69 @@ def test_discovery_is_saved_and_not_overwritten_while_an_inverter_is_offline(sel
         restarted = self._listed_gateway(["CE2223G800", "CE2225G400"], stored=gw._saved[("gateway", "discovery_pbgw_two_ac")]["inverters"])
         assert sorted(restarted._discovery) == ["CE2223G800", "CE2225G400"]
 
+    def test_failed_discovery_save_is_retried_after_a_wait(self):
+        """A save the storage refuses is kept pending and tried again after a wait, not on every status message."""
+        import gateway
+
+        gw = self._listed_gateway(["CE2223G800", "CE2225G400"])
+        storage = gw.base.components.get_component.return_value
+        real_save = storage.save
+        attempts = []
+
+        async def failing_save(module, filename, data, format="yaml", expiry=None, indent=None):
+            attempts.append(1)
+            return False
+
+        now = [1000.0]
+        real_monotonic = gateway._monotonic
+        gateway._monotonic = lambda: now[0]
+        try:
+            storage.save = failing_save
+            gw._process_telemetry(self._two_ac_status("ok").SerializeToString())
+            asyncio.run(gw._save_discovery())
+            assert attempts == [1]
+            assert gw._discovery_dirty is True
+            assert gw._saved == {}
+            assert self._logged(gw, "Warn", "failed to save inverter discovery")
+
+            # Still failing, but inside the wait: not tried again
+            asyncio.run(gw._save_discovery())
+            assert attempts == [1]
+
+            storage.save = real_save
+            now[0] += gateway.GATEWAY_DISCOVERY_SAVE_RETRY_SECONDS
+            asyncio.run(gw._save_discovery())
+            assert gw._discovery_dirty is False
+            assert sorted(gw._saved[("gateway", "discovery_pbgw_two_ac")]["inverters"]) == ["CE2223G800", "CE2225G400"]
+        finally:
+            gateway._monotonic = real_monotonic
+
+    def test_newly_bound_inverter_has_its_entities_on_the_same_status(self):
+        """An inverter auto-config has just bound is published before the API is declared started.
+
+        One the hub does not flag primary is skipped by the injection that runs ahead of
+        auto-config, so without a second pass its soc and size entities would not exist
+        until the next status message.
+        """
+        gw = self._listed_gateway(["CE2223G800", "CE2225G400"])
+
+        gw._process_telemetry(self._two_ac_status("not_primary").SerializeToString())
+
+        assert gw.api_started is True
+        assert gw._args["num_inverters"] == 2
+        assert gw._states["sensor.predbat_gateway_25g400_soc"] == 50
+        assert gw._states["sensor.predbat_gateway_25g400_battery_capacity"] == 9.5
+
+        # The same for a PV-only inverter the hub does not flag primary
+        gw = self._listed_gateway(["FD0000P001", "CH0000B002"])
+        status = self._pv_and_battery_status(pv_power=900)
+        status.inverters[0].primary = False
+
+        gw._process_telemetry(status.SerializeToString())
+
+        assert gw._pv_only_serials == ("FD0000P001",)
+        assert gw._states["sensor.predbat_gateway_00p001_pv_power"] == 900
+
     def test_no_serial_list_stores_nothing(self):
         """With no serial list nothing is recorded or saved, and auto-config uses what it finds."""
         gw = self._listed_gateway([])