refactor(metrics): replace packet score calculation with flood metrics from core

repeater/engine.py

@@ -22,7 +22,12 @@ from openhop_core.protocol.constants import (
     ROUTE_TYPE_TRANSPORT_DIRECT,
     ROUTE_TYPE_TRANSPORT_FLOOD,
 )
-from openhop_core.protocol.packet_utils import PacketHeaderUtils, PathUtils, packet_score
+from openhop_core.protocol.packet_utils import (
+    PacketHeaderUtils,
+    PathUtils,
+    flood_rx_metrics,
+    packet_score,
+)
 
 from repeater.airtime import AirtimeManager
 from repeater.data_acquisition import StorageCollector
@@ -263,11 +268,15 @@ class RepeaterHandler(BaseHandler):
             payload_type = (
                 packet.get_payload_type() if hasattr(packet, "get_payload_type") else None
             )
-            score = self.calculate_packet_score(
+            frame_len = packet.get_raw_length() if hasattr(packet, "get_raw_length") else 0
+            score = flood_rx_metrics(
+                frame_len,
                 snr,
-                len(packet.payload or b""),
                 self.radio_config["spreading_factor"],
-            )
+                self.radio_config["bandwidth"],
+                self.radio_config["coding_rate"],
+                self.radio_config["preamble_length"],
+            ).score
             self.neighbour_link_tracker.observe(
                 packet,
                 route_type=route_type,
@@ -591,11 +600,15 @@ class RepeaterHandler(BaseHandler):
         src_hash, dst_hash = self._packet_record_src_dst(packet, payload_type)
         pkt_hash_full = packet.calculate_packet_hash().hex().upper()
 
-        score = self.calculate_packet_score(
+        frame_len = packet.get_raw_length() if hasattr(packet, "get_raw_length") else 0
+        score = flood_rx_metrics(
+            frame_len,
             snr,
-            len(packet.payload or b""),
             self.radio_config["spreading_factor"],
-        )
+            self.radio_config["bandwidth"],
+            self.radio_config["coding_rate"],
+            self.radio_config["preamble_length"],
+        ).score
         self.neighbour_link_tracker.observe(
             packet,
             route_type=route_type,
@@ -738,9 +751,14 @@ class RepeaterHandler(BaseHandler):
             "length": payload_len,
             "rssi": rssi,
             "snr": snr,
-            "score": self.calculate_packet_score(
-                snr, payload_len, self.radio_config["spreading_factor"]
-            ),
+            "score": flood_rx_metrics(
+                packet.get_raw_length() if hasattr(packet, "get_raw_length") else 0,
+                snr,
+                self.radio_config["spreading_factor"],
+                self.radio_config["bandwidth"],
+                self.radio_config["coding_rate"],
+                self.radio_config["preamble_length"],
+            ).score,
             "tx_delay_ms": tx_delay_ms,
             "airtime_ms": airtime_ms,
             "transmitted": transmitted,

repeater/handler_helpers/trace.py

@@ -226,7 +226,7 @@ class TraceHelper:
             "score": (
                 self.repeater_handler.calculate_packet_score(
                     getattr(packet, "snr", 0.0),
-                    len(packet.payload or b""),
+                    packet.get_raw_length() if hasattr(packet, "get_raw_length") else 0,
                     self.repeater_handler.radio_config.get("spreading_factor", 8),
                 )
                 if self.repeater_handler

tests/test_engine.py

@@ -1233,7 +1233,7 @@ class TestNeighbourLinkObservation:
         payload_type = pkt.get_payload_type() if hasattr(pkt, "get_payload_type") else None
         score = handler.calculate_packet_score(
             snr,
-            len(pkt.payload or b""),
+            pkt.get_raw_length() if hasattr(pkt, "get_raw_length") else 0,
             handler.radio_config["spreading_factor"],
         )
         handler.neighbour_link_tracker.observe(
@@ -1309,18 +1309,22 @@ class TestNeighbourLinkObservation:
         assert len(snapshot) == 1
         assert snapshot[0]["peer_hash"] == "3B"
 
-    async def test_existing_packet_score_calculation_is_reused_unchanged(self, handler):
+    async def test_neighbour_link_score_uses_shared_flood_metrics(self, handler):
         handler.config["repeater"]["mode"] = "monitor"
         pkt = _make_hashed_flood_packet(["55"], hash_size=1)
-        with patch.object(handler, "calculate_packet_score", return_value=0.42) as score_mock:
+        with patch("repeater.engine.flood_rx_metrics") as metrics_mock:
+            metrics_mock.return_value = MagicMock(score=0.42)
             await handler(pkt, {"rssi": -81.0, "snr": 3.25}, local_transmission=False)
 
-        score_mock.assert_any_call(
+        metrics_mock.assert_any_call(
+            pkt.get_raw_length(),
             3.25,
-            len(pkt.payload or b""),
             handler.radio_config["spreading_factor"],
+            handler.radio_config["bandwidth"],
+            handler.radio_config["coding_rate"],
+            handler.radio_config["preamble_length"],
         )
-        assert score_mock.call_count >= 1
+        assert metrics_mock.call_count >= 1
         snapshot = handler.neighbour_link_tracker.snapshot()
         assert snapshot[0]["last_score"] == pytest.approx(0.42)