fix: node cache dropped service_type on load — a writer with no reader

Live-caught during LXMF propagation adoption (plan step 2b). to_dict()
has always written service_type, but _load_cache() restored 14 other
fields and silently dropped this one. Every gateway restart therefore
erased the RNS service type of every known node until it announced
again — up to 6h for a propagation node's 360-min interval.

Measured on moc immediately after the adoption restart: 2 of 9,115
cached entries carried service_type, and the oldest of those was stamped
90 seconds AFTER the restart. Everything heard before it lost the field.

honest_failure_modes #4 (reader/writer pairs wire together or fail
together), and it broke a real consumer: probe_lxmf_propagation_node_dark
matches the configured node by service_type, so after the restart that
ADOPTION ITSELF REQUIRES it reported our healthy, actively-serving node
as "NEVER been heard" — the exact wrong-hash fault it exists to catch.
The box had in fact heard it 7 times in 25h and had delivered a
store-and-forward message through it 10 minutes earlier.

Red-first: both tests fail with `assert None == 'LXMF_PROPAGATION'`
before the one-line restore. Second test pins the full save->load
round-trip so writer and reader fail together next time.

lint 0, parity in sync, full suite 9001 passed / 1 skipped.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

Author: Nursedude

src/gateway/node_tracker.py

@@ -708,6 +708,15 @@ def _load_cache(self):
                         node._state_machine = NodeStateMachine.from_dict(node_data['state_machine'])
                     except Exception as e:
                         logger.debug(f"Could not restore state machine: {e}")
+                # Restore the RNS service type. to_dict() has always written
+                # this; the loader used to drop it, so every restart erased
+                # the service type of every known node until it announced
+                # again — which for an LXMF propagation node is up to its
+                # 360-min interval. A writer with no reader (honest_failure_
+                # modes #4); it made probe_lxmf_propagation_node_dark report
+                # a healthy configured node as "never heard" (2026-07-21).
+                if node_data.get('service_type'):
+                    node.service_type = node_data['service_type']
                 # Restore favorites from cache (BaseUI 2.7+)
                 node.is_favorite = node_data.get('is_favorite', False)
                 if node_data.get('favorite_updated'):

tests/test_node_tracker.py

@@ -588,6 +588,62 @@ def test_load_cache(self, tmp_path):
             assert 'cached_1' in tracker._nodes
             assert tracker._nodes['cached_1'].name == 'Cached Node'
 
+    def test_load_cache_restores_service_type(self, tmp_path):
+        """service_type must survive the save/load round-trip.
+
+        Regression, live-caught 2026-07-21: ``to_dict()`` wrote service_type
+        but ``_load_cache()`` restored 14 other fields and silently dropped
+        this one, so every gateway restart erased the RNS service type of
+        every known node until it announced again (up to 6h for a propagation
+        node's 360-min interval).
+
+        That is honest_failure_modes #4 — a writer with no matching reader —
+        and it broke a real consumer: ``probe_lxmf_propagation_node_dark``
+        reads service_type to find the configured propagation node, so after
+        the restart that ADOPTION ITSELF REQUIRES it saw the node as "never
+        heard" and paged, while the node was healthy and serving.
+        """
+        cache_file = tmp_path / "node_cache.json"
+        cache_data = {
+            'version': 1,
+            'nodes': [{
+                'id': 'rns_3968a2eeac25e2e7',
+                'network': 'rns',
+                'name': 'propagation node',
+                'rns_hash': '3968a2eeac25e2e7a7961f25842d3d85',
+                'service_type': 'LXMF_PROPAGATION',
+                'last_seen': '2026-07-21T03:37:44.163446',
+            }]
+        }
+        cache_file.write_text(json.dumps(cache_data))
+
+        with patch.object(UnifiedNodeTracker, 'get_cache_file', return_value=cache_file):
+            tracker = UnifiedNodeTracker()
+
+            node = tracker._nodes['rns_3968a2eeac25e2e7']
+            assert node.service_type == 'LXMF_PROPAGATION'
+
+    def test_save_then_load_preserves_service_type(self, tmp_path):
+        """The full round-trip, not just the read half.
+
+        Pins writer and reader together so a future change to either side
+        fails here rather than fleet-wide six hours later.
+        """
+        cache_file = tmp_path / "node_cache.json"
+
+        with patch.object(UnifiedNodeTracker, 'get_cache_file', return_value=cache_file):
+            with patch.object(UnifiedNodeTracker, '_load_cache'):
+                tracker = UnifiedNodeTracker()
+                node = UnifiedNode(id="rns_abc", network="rns", name="pn")
+                node.service_type = "LXMF_PROPAGATION"
+                tracker.add_node(node)
+                tracker._save_cache()
+
+        with patch.object(UnifiedNodeTracker, 'get_cache_file', return_value=cache_file):
+            reloaded = UnifiedNodeTracker()
+
+        assert reloaded._nodes["rns_abc"].service_type == "LXMF_PROPAGATION"
+
     def test_load_cache_handles_missing_file(self, tmp_path):
         """Test loading when cache file doesn't exist."""
         cache_file = tmp_path / "nonexistent.json"