ADR-110: ESP32-C6 firmware extension (#764)

Closes the firmware-side ADR-110 design at v0.7.0-esp32 after a 38-iter /loop SOTA sprint.

Headline (bench, COM9+COM12 ESP32-C6):
- 99.56% cross-board RX, 104.1 µs smoothed offset stdev (≤100 µs §2.4 target met)
- 3.95× EMA suppression, 1.4 ppm crystal skew preserved

4 firmware releases: v0.6.7 / v0.6.8 / v0.6.9 / v0.7.0-esp32.
42 ADR-110 unit tests, 1761 v2 workspace tests, full Firmware CI + QEMU green.

archive/v1/tests/unit/test_esp32_binary_parser.py

@@ -19,11 +19,16 @@ from hardware.csi_extractor import (
     CSIExtractor,
     CSIParseError,
     CSIExtractionError,
+    SyncPacket,
+    SyncPacketParser,
 )
 
 # ADR-018 constants
 MAGIC = 0xC5110001
-HEADER_FMT = '<IBBHIIBB2x'
+# ADR-110: bytes 18-19 are now PPDU type + flags (used to be `2x` reserved).
+# Pre-ADR-110 firmware sends zeros for both, which round-trip as
+# ('ht_legacy', flags=all-false) — fully backwards compatible.
+HEADER_FMT = '<IBBHIIBBBB'
 HEADER_SIZE = 20
 
 
@@ -36,6 +41,8 @@ def build_binary_frame(
     rssi: int = -50,
     noise_floor: int = -90,
     iq_pairs: list = None,
+    ppdu_byte: int = 0,   # ADR-110: default 0 = HT/legacy (pre-ADR-110 behavior)
+    flags_byte: int = 0,  # ADR-110: default 0 = no flags set
 ) -> bytes:
     """Build an ADR-018 binary frame for testing."""
     if iq_pairs is None:
@@ -54,6 +61,8 @@ def build_binary_frame(
         sequence,
         rssi_u8,
         noise_u8,
+        ppdu_byte,
+        flags_byte,
     )
 
     iq_data = b''
@@ -63,6 +72,52 @@ def build_binary_frame(
     return header + iq_data
 
 
+class TestAdr110ByteEncoding:
+    """ADR-110: byte 18 = PPDU type, byte 19 = flags."""
+
+    def setup_method(self):
+        self.parser = ESP32BinaryParser()
+
+    def test_pre_adr110_zeros_decode_as_ht_legacy(self):
+        """Pre-ADR-110 firmware sends zeros → must surface as HT/legacy + no flags."""
+        frame = build_binary_frame()  # ppdu_byte=0, flags_byte=0 default
+        csi = self.parser.parse(frame)
+        assert csi.metadata['ppdu_type'] == 'ht_legacy'
+        assert csi.metadata['ppdu_type_raw'] == 0
+        assert csi.metadata['he_capable'] is False
+        assert csi.metadata['bw40'] is False
+        assert csi.metadata['stbc'] is False
+        assert csi.metadata['ldpc'] is False
+        assert csi.metadata['ieee802154_sync_valid'] is False
+
+    def test_he_su_decodes(self):
+        frame = build_binary_frame(ppdu_byte=1)
+        csi = self.parser.parse(frame)
+        assert csi.metadata['ppdu_type'] == 'he_su'
+        assert csi.metadata['he_capable'] is True
+
+    def test_he_mu_and_he_tb_decode(self):
+        for byte, expected in [(2, 'he_mu'), (3, 'he_tb')]:
+            csi = self.parser.parse(build_binary_frame(ppdu_byte=byte))
+            assert csi.metadata['ppdu_type'] == expected
+            assert csi.metadata['he_capable'] is True
+
+    def test_unknown_ppdu_byte(self):
+        csi = self.parser.parse(build_binary_frame(ppdu_byte=0xFF))
+        assert csi.metadata['ppdu_type'] == 'unknown'
+        assert csi.metadata['ppdu_type_raw'] == 0xFF
+        assert csi.metadata['he_capable'] is False
+
+    def test_all_flags_set_round_trip(self):
+        # bw40 (0x01) + STBC (0x04) + LDPC (0x08) + 15.4-sync (0x10) = 0x1D
+        csi = self.parser.parse(build_binary_frame(ppdu_byte=1, flags_byte=0x1D))
+        assert csi.metadata['bw40'] is True
+        assert csi.metadata['stbc'] is True
+        assert csi.metadata['ldpc'] is True
+        assert csi.metadata['ieee802154_sync_valid'] is True
+        assert csi.metadata['adr018_flags_raw'] == 0x1D
+
+
 class TestESP32BinaryParser:
     """Tests for ESP32BinaryParser."""
 
@@ -204,3 +259,172 @@ class TestESP32BinaryParser:
             await extractor.disconnect()
 
         asyncio.run(run_test())
+
+
+# ============================================================================
+# ADR-110 §A0.12 — SyncPacket / SyncPacketParser tests (firmware v0.6.9+)
+# ============================================================================
+
+SYNC_MAGIC = 0xC511A110
+SYNC_SIZE = 32
+SYNC_FMT = '<IBBBBQQI4x'
+
+
+def build_sync_packet(
+    node_id: int = 9,
+    proto_ver: int = 1,
+    is_leader: bool = False,
+    is_valid: bool = True,
+    smoothed_used: bool = True,
+    local_us: int = 28798450,
+    epoch_us: int = 27634885,
+    sequence: int = 20,
+) -> bytes:
+    flags = 0
+    if is_leader:     flags |= 0x01
+    if is_valid:      flags |= 0x02
+    if smoothed_used: flags |= 0x04
+    return struct.pack(
+        SYNC_FMT,
+        SYNC_MAGIC,
+        node_id, proto_ver, flags, 0,
+        local_us, epoch_us, sequence,
+    )
+
+
+class TestSyncPacketParser:
+    """ADR-110 §A0.12: 32-byte UDP sync packet (magic 0xC511A110)."""
+
+    def test_follower_typical_packet_roundtrips(self):
+        """Match the COM9-witnessed sync-pkt #1 byte-for-byte."""
+        raw = build_sync_packet(
+            node_id=9, is_leader=False, is_valid=True, smoothed_used=True,
+            local_us=28798450, epoch_us=27634885, sequence=20,
+        )
+        assert len(raw) == SYNC_SIZE
+        pkt = SyncPacketParser.parse(raw)
+        assert isinstance(pkt, SyncPacket)
+        assert pkt.node_id == 9
+        assert pkt.proto_ver == 1
+        assert pkt.is_leader is False
+        assert pkt.is_valid is True
+        assert pkt.smoothed_used is True
+        assert pkt.local_us == 28798450
+        assert pkt.epoch_us == 27634885
+        assert pkt.sequence == 20
+        # The 1.16-second boot delta from §A0.10 should be recoverable
+        assert pkt.local_us - pkt.epoch_us == 1163565
+
+    def test_leader_packet_has_local_close_to_epoch(self):
+        """COM12 (leader) had flags=0x03 and epoch ≈ local."""
+        raw = build_sync_packet(
+            node_id=12, is_leader=True, is_valid=True, smoothed_used=False,
+            local_us=28864932, epoch_us=28864939, sequence=20,
+        )
+        pkt = SyncPacketParser.parse(raw)
+        assert pkt.node_id == 12
+        assert pkt.is_leader is True
+        assert pkt.is_valid is True
+        assert pkt.smoothed_used is False
+        assert pkt.flags_raw == 0x03
+        assert pkt.local_us - pkt.epoch_us == -7  # leader has zero offset
+
+    def test_magic_mismatch_raises(self):
+        """A non-sync datagram must not silently decode."""
+        raw = bytearray(build_sync_packet())
+        raw[0] = 0x01  # corrupt magic low byte
+        with pytest.raises(CSIParseError, match="magic mismatch"):
+            SyncPacketParser.parse(bytes(raw))
+
+    def test_short_packet_raises(self):
+        """Below 32 bytes must error early, not silently truncate."""
+        raw = build_sync_packet()[:16]
+        with pytest.raises(CSIParseError, match="too short"):
+            SyncPacketParser.parse(raw)
+
+    def test_all_flag_combinations(self):
+        """Each flag bit decodes independently."""
+        for is_leader in (False, True):
+            for is_valid in (False, True):
+                for smoothed_used in (False, True):
+                    raw = build_sync_packet(
+                        is_leader=is_leader,
+                        is_valid=is_valid,
+                        smoothed_used=smoothed_used,
+                    )
+                    pkt = SyncPacketParser.parse(raw)
+                    assert pkt.is_leader == is_leader
+                    assert pkt.is_valid == is_valid
+                    assert pkt.smoothed_used == smoothed_used
+
+    def test_dispatch_distinguishes_csi_from_sync(self):
+        """A host can pick CSI vs sync by leading magic."""
+        csi_magic = struct.unpack_from('<I', build_binary_frame(), 0)[0]
+        sync_magic = struct.unpack_from('<I', build_sync_packet(), 0)[0]
+        assert csi_magic == ESP32BinaryParser.MAGIC
+        assert sync_magic == SyncPacketParser.MAGIC
+        assert csi_magic != sync_magic
+
+    def test_apply_to_local_recovers_epoch_at_sync_point(self):
+        """ADR-110 iter 26 — Python parity with Rust's `apply_to_local`.
+        At local_at_frame == sync.local_us, the recovered mesh time must
+        equal sync.epoch_us exactly."""
+        pkt = SyncPacketParser.parse(build_sync_packet(
+            local_us=28_798_450, epoch_us=27_634_885, sequence=20,
+        ))
+        assert pkt.apply_to_local(pkt.local_us) == pkt.epoch_us
+        assert pkt.local_minus_epoch_us() == 1_163_565  # §A0.10's bench number
+
+    def test_apply_to_local_preserves_inter_frame_delta(self):
+        """A frame arriving 5 s after the sync packet on the follower's
+        local clock must produce a mesh time exactly 5 s after sync.epoch_us."""
+        pkt = SyncPacketParser.parse(build_sync_packet(
+            local_us=28_798_450, epoch_us=27_634_885, sequence=20,
+        ))
+        local_at_frame = pkt.local_us + 5_000_000
+        assert pkt.apply_to_local(local_at_frame) == pkt.epoch_us + 5_000_000
+
+    def test_mesh_aligned_us_for_sequence_matches_rust(self):
+        """Cross-language parity with Rust's
+        `end_to_end_sync_decode_then_frame_mesh_recovery` test —
+        100 frames after sync.sequence at 20 fps = sync.epoch_us + 5 s."""
+        pkt = SyncPacketParser.parse(build_sync_packet(
+            local_us=28_798_450, epoch_us=27_634_885, sequence=20,
+        ))
+        mesh = pkt.mesh_aligned_us_for_sequence(120, 20.0)
+        assert mesh == pkt.epoch_us + 5_000_000
+        # Both paths (apply_to_local + interpolation) must agree
+        local_at = pkt.local_us + 5_000_000
+        assert pkt.apply_to_local(local_at) == mesh
+
+    def test_canonical_wire_bytes_match_rust_decoder(self):
+        """ADR-110 iter 21 — cross-language wire-format conformance gate.
+
+        These exact bytes also appear pinned in the Rust hardware crate's
+        `canonical_wire_bytes_match_python_decoder` test (same field
+        values, encoded by Rust's `SyncPacket::to_bytes`). If Python's
+        hardcoded hex stops matching what Rust produces from the equivalent
+        SyncPacket struct, ONE of the decoders has drifted from the wire.
+
+        Canonical packet: COM9 sync-pkt #1 from §A0.12 live capture.
+        """
+        canonical = bytes.fromhex(
+            "10a111c509010600"   # magic LE + node=9 + ver=1 + flags=0x06 + reserved
+            "f26db70100000000"   # local_us = 28_798_450 (LE u64)
+            "c5aca50100000000"   # epoch_us = 27_634_885 (LE u64)
+            "1400000000000000"   # sequence = 20 (LE u32) + 4 reserved bytes
+        )
+        assert len(canonical) == SyncPacketParser.SIZE == 32
+
+        pkt = SyncPacketParser.parse(canonical)
+        assert pkt.node_id == 9
+        assert pkt.proto_ver == 1
+        assert pkt.flags_raw == 0x06
+        assert pkt.is_leader is False
+        assert pkt.is_valid is True
+        assert pkt.smoothed_used is True
+        assert pkt.local_us == 28_798_450
+        assert pkt.epoch_us == 27_634_885
+        assert pkt.sequence == 20
+        # Recovered offset matches §A0.10's measured 1.16-second boot delta.
+        assert pkt.local_us - pkt.epoch_us == 1_163_565