@@ -42,6 +42,9 @@ the GitHub release body should be rendered from the matching version section her
 - Fixed stale callback-session inventory that could outlive its physical TCP
   socket, suppress a new callback request, and leave Home Assistant waiting for
   a connection that no longer existed.
+- Fixed Protocol 3/4 optional-register polling so one silent collector session
+  fails fast instead of expanding into minutes of per-register retries. Support
+  archives also refresh their runtime snapshot after a capture reconnect.
 - Fixed fully silent callback collectors that open a TCP session without an
   initial payload. Home Assistant now performs one bounded FC=1 identity
   challenge on the exact observed session, accepts only a correlated full-PN
 
@@ -1041,13 +1041,13 @@ async def _read_optional_specs(
         try:
             raw_values = await session.read_holding(start_register, register_count)
         except Exception as exc:
-            if not _is_optional_spec_error(exc):
+            if not _is_explicit_optional_register_rejection(exc):
                 raise
             for spec in grouped_specs:
                 try:
                     raw_values = await session.read_holding(spec.register, spec.word_count)
                 except Exception as fallback_exc:
-                    if not _is_optional_spec_error(fallback_exc):
+                    if not _is_explicit_optional_register_rejection(fallback_exc):
                         raise
                     continue
                 decoded.update(_decode_block(spec.register, raw_values, (spec,)))
@@ -1067,7 +1067,7 @@ async def _read_optional_ascii_ranges(
         try:
             raw_values = await session.read_holding(register, word_count)
         except Exception as exc:
-            if not _is_optional_spec_error(exc):
+            if not _is_explicit_optional_register_rejection(exc):
                 raise
             continue
         text = _decode_ascii_words(raw_values).strip()
@@ -1100,11 +1100,24 @@ async def _read_missing_optional_probe_details(
     return decoded
 
 
-def _is_optional_spec_error(exc: Exception) -> bool:
-    """Return whether one optional-register read failure should be ignored."""
+def _is_explicit_optional_register_rejection(exc: Exception) -> bool:
+    """Return whether the inverter explicitly rejected an optional register.
+
+    A Modbus exception response (normally illegal function/address/value) is
+    positive wire evidence that the exact optional range is unavailable.  It
+    is therefore safe to split a rejected group into individual reads, or to
+    skip one individually rejected field.
+
+    ``request_timeout`` is deliberately NOT accepted here.  Silence says
+    nothing about register support: the collector session may have stopped
+    responding.  Treating it as an optional-field rejection used to fan one
+    lost session out into every grouped and individual optional read (hundreds
+    of seconds on the Protocol 3/4 maps), preventing runtime recovery from
+    acquiring the operation boundary.
+    """
 
     if isinstance(exc, ModbusError):
-        return True
+        return str(exc).startswith("exception_code:")
     return str(exc).startswith("missing_register:")
 
 
 
@@ -461,6 +461,7 @@ async def _async_build_support_package_payloads(
         """Build support bundle payload and raw capture under one runtime operation lock."""
 
         async with self._runtime_operation_lock:
+            refreshed_connected = bool(getattr(self.data, "connected", False))
             try:
                 snapshot = await self._async_update_data_with_runtime_lock()
             except Exception as exc:  # noqa: BLE001 - support export must remain available
@@ -472,12 +473,12 @@ async def _async_build_support_package_payloads(
             else:
                 if snapshot is not None:
                     self.data = snapshot
+                    refreshed_connected = bool(
+                        getattr(snapshot, "connected", False)
+                    )
 
             collector_registry_lookup = await self._async_collector_registry_lookup()
-            support_bundle_payload = self._build_support_bundle_payload(
-                integration_build_values=integration_build_values,
-                collector_registry_lookup=collector_registry_lookup,
-            )
+            capture_completed = False
             try:
                 raw_capture = await self._runtime.async_capture_support_evidence()
             except Exception as exc:
@@ -487,6 +488,32 @@ async def _async_build_support_package_payloads(
                     "captured_ranges": [],
                     "range_failures": [],
                 }
+            else:
+                capture_completed = True
+
+            # Evidence capture owns its own bounded reconnect path.  When the
+            # pre-capture refresh was offline but the capture then completed,
+            # rebuild one runtime snapshot on the now-live session before
+            # serializing the bundle.  Previously the bundle was frozen before
+            # capture, so one archive could claim "offline" while its raw
+            # capture had just read every planned range successfully.
+            if capture_completed and not refreshed_connected:
+                try:
+                    snapshot = await self._async_update_data_with_runtime_lock()
+                except Exception as exc:  # noqa: BLE001 - preserve captured evidence
+                    logger.warning(
+                        "Support archive post-capture refresh failed for entry %s: %s",
+                        self.config_entry.entry_id,
+                        exc,
+                    )
+                else:
+                    if snapshot is not None:
+                        self.data = snapshot
+
+            support_bundle_payload = self._build_support_bundle_payload(
+                integration_build_values=integration_build_values,
+                collector_registry_lookup=collector_registry_lookup,
+            )
 
         return support_bundle_payload, raw_capture
 
 
@@ -10772,6 +10772,76 @@ async def _run() -> None:
         self.assertEqual(len(notifications), 1)
         self.assertIn("polling cycle is using", notifications[0]["body"])
 
+    def test_support_package_refreshes_snapshot_after_capture_reconnect(self) -> None:
+        async def _run() -> None:
+            coordinator = object.__new__(self.coordinator_module.EybondLocalCoordinator)
+            coordinator.config_entry = types.SimpleNamespace(entry_id="entry-support")
+            coordinator._runtime_operation_lock = asyncio.Lock()
+            coordinator.data = self.RuntimeSnapshot(connected=False)
+            events: list[str] = []
+            snapshots = iter(
+                (
+                    self.RuntimeSnapshot(
+                        connected=False,
+                        values={"runtime_session_state": "offline"},
+                    ),
+                    self.RuntimeSnapshot(
+                        connected=True,
+                        values={"runtime_session_state": "online"},
+                    ),
+                )
+            )
+
+            async def _refresh():
+                snapshot = next(snapshots)
+                events.append(f"refresh:{snapshot.connected}")
+                return snapshot
+
+            async def _registry_lookup():
+                events.append("registry")
+                return ("found", object())
+
+            async def _capture():
+                events.append("capture")
+                return {
+                    "capture_kind": "modbus_register_dump",
+                    "captured_ranges": [{"start": 100, "count": 10}],
+                    "range_failures": [],
+                }
+
+            def _build_payload(**_kwargs):
+                events.append("build")
+                return {
+                    "runtime": {
+                        "connected": coordinator.data.connected,
+                        "values": dict(coordinator.data.values),
+                    }
+                }
+
+            coordinator._async_update_data_with_runtime_lock = _refresh
+            coordinator._async_collector_registry_lookup = _registry_lookup
+            coordinator._runtime = types.SimpleNamespace(
+                async_capture_support_evidence=_capture
+            )
+            coordinator._build_support_bundle_payload = _build_payload
+
+            payload, raw_capture = await coordinator._async_build_support_package_payloads(
+                integration_build_values={}
+            )
+
+            self.assertEqual(
+                events,
+                ["refresh:False", "registry", "capture", "refresh:True", "build"],
+            )
+            self.assertTrue(payload["runtime"]["connected"])
+            self.assertEqual(
+                payload["runtime"]["values"]["runtime_session_state"],
+                "online",
+            )
+            self.assertEqual(raw_capture["capture_kind"], "modbus_register_dump")
+
+        asyncio.run(_run())
+
 
 if __name__ == "__main__":
     unittest.main()
@@ -18,6 +18,7 @@
     SmgModbusDriver,
     _apply_capability_read_back,
     _decode_block,
+    _read_optional_specs,
     _support_capture_ranges,
 )
 from custom_components.eybond_local.drivers.read_result import (  # noqa: E402
@@ -36,7 +37,10 @@
     set_external_register_schema_roots,
 )
 from custom_components.eybond_local.models import DetectedInverter, ProbeTarget  # noqa: E402
-from custom_components.eybond_local.payload.modbus import crc16_modbus  # noqa: E402
+from custom_components.eybond_local.payload.modbus import (  # noqa: E402
+    ModbusError,
+    crc16_modbus,
+)
 from custom_components.eybond_local.telemetry import (  # noqa: E402
     TelemetryFreshness,
     TypedTelemetryFrame,
@@ -528,6 +532,85 @@ async def test_issue_13_sandisolar_fingerprint_uses_protocol_4_schema(self) -> N
         self.assertEqual(values["inverter_temperature"], 35)
         self.assertNotEqual(values["inverter_temperature"], 5001)
 
+    async def test_issue_13_sandisolar_timeout_does_not_fan_out_optional_reads(
+        self,
+    ) -> None:
+        """One silent session must not become a 55-register timeout cascade."""
+
+        driver = SmgModbusDriver()
+        target = ProbeTarget(devcode=0x0001, collector_addr=0xFF, device_addr=0x01)
+        inverter = DetectedInverter(
+            driver_key="modbus_smg",
+            protocol_family="modbus_smg",
+            model_name="Sandisolar SD 11KP48V WIFI",
+            serial_number="92B32511113147",
+            probe_target=target,
+            variant_key="sandisolar_sd_11kp48v_wifi",
+            profile_name="modbus_smg/models/sandisolar_sd_11kp48v_wifi.json",
+            register_schema_name=(
+                "modbus_smg/models/sandisolar_sd_11kp48v_wifi.json"
+            ),
+            capabilities=(),
+        )
+        schema = load_register_schema(inverter.register_schema_name)
+        self.assertEqual(len(schema.spec_set("aux_config")), 55)
+
+        class _Session:
+            def __init__(self) -> None:
+                self.calls: list[tuple[int, int]] = []
+
+            async def read_holding(self, register: int, count: int) -> list[int]:
+                self.calls.append((register, count))
+                if (register, count) in {(100, 10), (198, 34), (600, 57)}:
+                    return [0] * count
+                raise ModbusError("request_timeout")
+
+        session = _Session()
+        with patch.object(
+            SmgModbusDriver,
+            "_session",
+            staticmethod(lambda *_args, **_kwargs: session),
+        ):
+            with self.assertRaisesRegex(ModbusError, "^request_timeout$"):
+                await driver.async_read_values(object(), inverter)
+
+        self.assertEqual(
+            session.calls,
+            [(100, 10), (198, 34), (600, 57), (171, 1)],
+        )
+
+    async def test_explicit_optional_group_rejection_keeps_single_read_fallback(
+        self,
+    ) -> None:
+        """An explicit illegal-range reply may still isolate supported fields."""
+
+        schema = load_register_schema(
+            "modbus_smg/models/sandisolar_sd_11kp48v_wifi.json"
+        )
+        specs = tuple(
+            spec
+            for spec in schema.spec_set("aux_config")
+            if 252 <= spec.register <= 256
+        )
+        self.assertEqual(len(specs), 5)
+
+        class _Session:
+            def __init__(self) -> None:
+                self.calls: list[tuple[int, int]] = []
+
+            async def read_holding(self, register: int, count: int) -> list[int]:
+                self.calls.append((register, count))
+                if count > 1:
+                    raise ModbusError("exception_code:2")
+                return [register]
+
+        session = _Session()
+        values = await _read_optional_specs(session, specs)
+
+        self.assertEqual(session.calls[0], (252, 5))
+        self.assertEqual(session.calls[1:], [(register, 1) for register in range(252, 257)])
+        self.assertEqual(set(values), {spec.key for spec in specs})
+
     async def test_probe_selects_hhs_11kw_telemetry_without_anj_controls(self) -> None:
         driver = SmgModbusDriver()
         target = ProbeTarget(devcode=0x0001, collector_addr=0xFF, device_addr=0x01)