Merge branch 'develop' into serialHal

fix: right-size warm tier for constrained platforms (#10746 , #10705 ) (#10759 )
* fix: right-size warm tier for constrained platforms and feed RP2040 watchdog during NodeDB save * fix: size warm tier and traffic cache per-MCU RAM, lowering no-PSRAM ESP32 (classic/S2/C3) tiers * docs: document nRF52/RP2040 #else fall-through in warm tier and TM cache cascades
2026-06-22 16:16:32 -05:00 · 2026-06-22 06:21:50 -05:00 · 2026-06-21 08:17:09 -05:00 · 2026-06-20 20:35:14 -05:00 · 2026-06-20 17:08:29 -05:00 · 2026-06-19 20:49:48 -05:00
65 changed files with 5653 additions and 1255 deletions
@@ -0,0 +1,277 @@
+# LoRa Region → Preset Compatibility — Client Implementation Spec
+
+**Status:** Draft for 2.8 · **Audience:** Meshtastic client app developers (Android first,
+Apple second, then web/python) · **Firmware side:** implemented in `firmware`
+(`FromRadio.region_presets`, see below).
+
+> This document lives in the firmware repo while the feature is developed. It is meant to
+> graduate to `meshtastic/protobufs` (and/or the docs site) alongside the upstream protobuf
+> PR that reserves `FromRadio` field **19**.
+
+---
+
+## 1. Why this exists
+
+For 2.8 the LoRa regions and modem presets were reworked. **Not every modem preset is legal
+in every region** — narrow EU SRD bands, the EU 868 "narrow" band, amateur/ham bands, and
+the 2.4 GHz band each accept only a specific subset of presets. The firmware already
+enforces this internally (it clamps or rejects illegal combinations), but until now a client
+had no way to _know_ the rules, so a user could pick an illegal region+preset pair in the UI
+and only discover the problem after the device silently corrected it.
+
+This feature has the firmware **declare the legal region→preset combinations** to the client
+during the `want_config` handshake, so the client UI can constrain the preset picker to the
+valid set for the currently selected region (and warn about licensed-only bands). It is
+purely advisory metadata — the firmware remains the source of truth and still
+validates/clamps on its own.
+
+---
+
+## 2. Protocol additions
+
+Three new messages in `meshtastic/mesh.proto`, plus one new `FromRadio` oneof variant.
+
+### 2.1 `FromRadio.region_presets` (field 19)
+
+```proto
+message FromRadio {
+  uint32 id = 1;
+  oneof payload_variant {
+    // ... fields 2..18 unchanged ...
+    LoRaRegionPresetMap region_presets = 19;
+  }
+}
+```
+
+### 2.2 Messages
+
+```proto
+// A distinct set of legal modem presets shared by one or more LoRa regions.
+message LoRaPresetGroup {
+  repeated Config.LoRaConfig.ModemPreset presets = 1;       // legal presets for this group
+  Config.LoRaConfig.ModemPreset         default_preset = 2; // always one of `presets`
+  bool                                  licensed_only = 3;  // ham/amateur band → warn/gate
+}
+
+// Associates a single LoRa region with its preset group (by index).
+message LoRaRegionPresets {
+  Config.LoRaConfig.RegionCode region = 1;
+  uint32                       group_index = 2; // index into LoRaRegionPresetMap.groups
+}
+
+// The full map, delivered grouped to fit one FromRadio packet.
+message LoRaRegionPresetMap {
+  repeated LoRaPresetGroup    groups = 1;        // each distinct preset list
+  repeated LoRaRegionPresets  region_groups = 2; // every known region → a group index
+}
+```
+
+### 2.3 Why grouped (and the size envelope clients should respect)
+
+A `FromRadio` packet is capped at **512 bytes** (`MAX_TO_FROM_RADIO_SIZE`). Most regions
+share one identical preset list (the "standard" 9-preset list), so the map is delivered
+**grouped**: `groups` holds each _distinct_ preset list once, and `region_groups` maps every
+known region to one of those groups by index. This keeps the encoded size additive
+(`groups` + `region_groups`) rather than multiplicative, well under the cap.
+
+nanopb (firmware) array bounds — clients do **not** need to enforce these, but they bound
+what you can receive:
+
+| field                               | max_count                            |
+| ----------------------------------- | ------------------------------------ |
+| `LoRaRegionPresetMap.groups`        | 8                                    |
+| `LoRaRegionPresetMap.region_groups` | 38 (= number of `RegionCode` values) |
+| `LoRaPresetGroup.presets`           | 11                                   |
+
+---
+
+## 3. When it is delivered
+
+`region_presets` is sent **once** during the `want_config` handshake, as a single
+`FromRadio` message, in this position:
+
+```text
+my_info → (deviceuiConfig) → node_info(self) → metadata → region_presets → channel… → config… → moduleConfig… → node_info(others)… → fileInfo… → config_complete_id → (live packets)
+```
+
+i.e. **immediately after `metadata` and before the first `channel`**.
+
+- It is included for a normal full `want_config` and for the **config-only** nonce.
+- It is **omitted** for the **nodes-only** nonce (that path skips metadata/config entirely).
+- A client must **not** assume it always arrives (see §5).
+
+---
+
+## 4. Decoding into a usable lookup
+
+Flatten the grouped wire form into `Map<RegionCode, RegionPresetInfo>`:
+
+```text
+struct RegionPresetInfo { Set<ModemPreset> presets; ModemPreset default; bool licensedOnly }
+
+fun decode(map: LoRaRegionPresetMap): Map<RegionCode, RegionPresetInfo> {
+  result = {}
+  for (rg in map.region_groups) {
+    if (rg.group_index >= map.groups.size) continue   // defensive: malformed/forward data
+    g = map.groups[rg.group_index]
+    result[rg.region] = RegionPresetInfo(
+      presets = g.presets.toSet(),
+      default = g.default_preset,
+      licensedOnly = g.licensed_only)
+  }
+  return result
+}
+```
+
+Persist this map alongside the rest of the downloaded config so the LoRa config screen can
+read it synchronously.
+
+---
+
+## 5. Semantics & rules (the load-bearing part)
+
+These rules are what keep the UX correct across firmware versions. Implement all of them.
+
+1. **Absent region ⇒ no constraint.** If a `RegionCode` does not appear in `region_groups`,
+   the client has _no_ compatibility info for it and **must not restrict** its preset
+   choices (fall back to allowing the full `ModemPreset` list). This happens for a handful
+   of `RegionCode` enum values that have no firmware band table entry (today: `EU_874`,
+   `EU_917`, `ITU1_70CM`, `ITU2_70CM`, `ITU3_70CM`).
+
+2. **Absent message ⇒ no constraint.** Firmware older than 2.8 never sends `region_presets`.
+   New clients **must** tolerate the message being absent entirely and keep their existing
+   (unconstrained) behavior. Do not block the config screen waiting for it.
+
+3. **`default_preset`** is always a member of that group's `presets`. Use it to pre-select a
+   preset when the user switches to a region whose valid set does not include the currently
+   selected preset (instead of leaving an illegal selection or guessing).
+
+4. **`licensed_only`** marks ham/amateur bands. Surface a warning or gate (the firmware also
+   requires the operator's `is_licensed` flag for these regions; coordinate the two so the
+   user isn't allowed to pick a licensed band without acknowledging licensing).
+
+5. **EU region auto-swap caveat.** The firmware treats the EU sibling regions
+   (`EU_868` / `EU_866` / `EU_N_868`) specially: if the user is in one of them and selects a
+   preset that belongs to a sibling's list, the firmware **swaps the region** rather than
+   rejecting the preset. Consequence for clients: **do not assume the region is immutable
+   across a preset change** — after an admin config write, re-read the resulting
+   `LoRaConfig` and reflect the (possibly changed) region back into the UI.
+
+6. **Use it as a UI guard, not a validator of truth.** The firmware still validates/clamps
+   on its own. The map exists to prevent the user from _selecting_ an illegal combo; it is
+   not a security or correctness boundary.
+
+---
+
+## 6. UI/UX recommendations
+
+- In the LoRa config screen, when a region is selected, **filter/enable the modem-preset
+  picker to that region's `presets`** (when `use_preset`/`use_modem_preset` is on).
+- If the current preset is not in the newly selected region's set, switch the selection to
+  that region's `default_preset`.
+- Show a **licensed badge / confirmation** for regions where `licensed_only == true`.
+- If a region is absent from the map (rule §5.1) or the whole message is absent (§5.2),
+  render the full preset list as before — never show an empty picker.
+
+---
+
+## 7. Forward / backward compatibility
+
+- **Old clients, new firmware:** an unknown `FromRadio` oneof variant (field 19) is ignored
+  by protobuf/nanopb decoders; the relative ordering of the known messages is unchanged, so
+  existing apps are unaffected.
+- **New clients, old firmware:** message simply never arrives → treat as "no constraints"
+  (§5.2).
+- **Enum growth:** new `RegionCode`/`ModemPreset` values may appear over time. Decoders
+  should pass through unknown enum values rather than crashing; an unknown region in
+  `region_groups` is harmless (the client just won't have a localized name for it).
+
+---
+
+## 8. Platform notes
+
+> Verified against the `main` branch of each repo. Both have been refactored away from
+> older layouts; re-pin file paths against a specific commit if you need them durable.
+
+### 8.1 Android — `meshtastic/Meshtastic-Android` (Kotlin / Compose, KMP)
+
+- **Protobufs are a published Maven artifact, _not_ a submodule.** Declared in
+  `gradle/libs.versions.toml` (`org.meshtastic:protobufs`, currently `2.7.25`); generated
+  package is **`org.meshtastic.proto`**. **A `region_presets`-aware build requires a new
+  published `org.meshtastic:protobufs` release**, then bumping that one version string.
+- **The protobufs are Wire-generated**, so the `FromRadio` oneof is **not** a
+  `payloadVariantCase` enum — each arm is a **nullable field**. Handle the new variant in
+  `FromRadioPacketHandlerImpl.handleFromRadio(...)`
+  (`core/data/.../manager/FromRadioPacketHandlerImpl.kt`) by adding a
+  `regionPresets != null -> …` arm to the existing `when { … }`, delegating to a handler
+  (mirror `handleLocalMetadata` / `handleConfigComplete`).
+- **State holder:** expose the decoded map from `RadioConfigRepository` /
+  `RadioConfigRepositoryImpl` as a `Flow` (mirroring `localConfigFlow`/`channelSetFlow`),
+  consumed by `feature/settings/.../radio/RadioConfigViewModel.kt`.
+- **UI:** the region & preset dropdowns are `DropDownPreference`s in
+  `feature/settings/.../radio/component/LoRaConfigItemList.kt` (public composable
+  `LoRaConfigScreen`). Gate/filter the `ChannelOption` (preset) dropdown by the selected
+  `RegionInfo`'s entry in the map.
+
+### 8.2 Apple — `meshtastic/Meshtastic-Apple` (Swift / SwiftUI)
+
+- **Protobufs are vendored** into a local Swift package `MeshtasticProtobufs`
+  (`MeshtasticProtobufs/Sources/meshtastic/*.pb.swift`), generated from the `protobufs` git
+  submodule via `scripts/gen_protos.sh`. **To get field 19:** advance the `protobufs`
+  submodule, run `scripts/gen_protos.sh`, commit the regenerated `.pb.swift` + submodule
+  pointer. (No published-artifact dependency — Apple can regenerate from any commit.)
+- **Dispatch:** `AccessoryManager.processFromRadio(_:)`
+  (`Meshtastic/Accessory/Accessory Manager/AccessoryManager.swift`) is a real
+  `switch decodedInfo.payloadVariant { … }` — add a `.regionPresets` case, with the handler
+  in `AccessoryManager+FromRadio.swift` (mirror `handleConfig` / `handleMetadata`).
+- **Persistence:** config is **SwiftData** (`@Model` entities), upserted via
+  `MeshPackets`/`UpdateSwiftData.swift`. Store the decoded map (e.g. on a settings/connection
+  model) so the LoRa view can read it.
+- **UI:** `Meshtastic/Views/Settings/Config/LoRaConfig.swift` (`struct LoRaConfig: View`)
+  has the `Picker("Region", …)` (`RegionCodes.userSelectable`) and `Picker("Presets", …)`
+  (`ModemPresets.userSelectable`, gated on `usePreset`). Filter the presets picker by the
+  selected region's entry. Enums live in `Meshtastic/Enums/LoraConfigEnums.swift`.
+
+### 8.3 Other clients
+
+- **python (`meshtastic` / Meshtastic-python)** and **web** consume the published protobufs;
+  they will see `region_presets` once their protobuf dependency includes field 19, and can
+  ignore it until then (it decodes as an unknown field).
+
+---
+
+## 9. Reference payload (current firmware table)
+
+For decoder unit tests. With the 2.8 region table, the firmware emits **6 groups**. Group
+indices are assigned in region-table order (first region to use a profile creates its group),
+so they are stable as listed here:
+
+| group_index             | default_preset | licensed_only | presets                                                                                                        |
+| ----------------------- | -------------- | ------------- | -------------------------------------------------------------------------------------------------------------- |
+| 0 (standard)            | `LONG_FAST`    | false         | LONG_FAST, LONG_SLOW, MEDIUM_SLOW, MEDIUM_FAST, SHORT_SLOW, SHORT_FAST, LONG_MODERATE, SHORT_TURBO, LONG_TURBO |
+| 1 (EU 868)              | `LONG_FAST`    | false         | LONG_FAST, LONG_SLOW, MEDIUM_SLOW, MEDIUM_FAST, SHORT_SLOW, SHORT_FAST, LONG_MODERATE                          |
+| 2 (EU 866 SRD / "lite") | `LITE_FAST`    | false         | LITE_FAST, LITE_SLOW                                                                                           |
+| 3 (EU 868 narrow)       | `NARROW_SLOW`  | false         | NARROW_FAST, NARROW_SLOW                                                                                       |
+| 4 (ham 20 kHz)          | `TINY_FAST`    | **true**      | TINY_FAST, TINY_SLOW                                                                                           |
+| 5 (ham 100 kHz)         | `NARROW_SLOW`  | **true**      | NARROW_FAST, NARROW_SLOW                                                                                       |
+
+`region_groups` (region → group_index):
+
+| group | regions                                                                                                                                                               |
+| ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0     | US, EU_433, CN, JP, ANZ, ANZ_433, RU, KR, TW, IN, NZ_865, TH, UA_433, UA_868, MY_433, MY_919, SG_923, PH_433, PH_868, PH_915, KZ_433, KZ_863, NP_865, BR_902, LORA_24 |
+| 1     | EU_868                                                                                                                                                                |
+| 2     | EU_866                                                                                                                                                                |
+| 3     | EU_N_868                                                                                                                                                              |
+| 4     | ITU1_2M, ITU2_2M, ITU3_2M                                                                                                                                             |
+| 5     | ITU2_125CM                                                                                                                                                            |
+
+> Note groups **3** and **5** carry the same preset list (NARROW\_\*) but are distinct groups
+> because they differ in `licensed_only`. Decoders must key on the group, not on the preset
+> list, to preserve the licensing flag.
+>
+> Regions **absent** from the table (no constraint info; see §5.1): `EU_874`, `EU_917`,
+> `ITU1_70CM`, `ITU2_70CM`, `ITU3_70CM`.
+
+This table is generated from the firmware's region table at runtime; treat the firmware as
+authoritative and these values as the expected snapshot for the 2.8 table.
@@ -0,0 +1,456 @@
+# NextHop direct-message reliability on dense meshes — findings & plan
+
+**Status:** Implemented — mitigations and tests in `PR3-tmm-nexthop`
+**Date:** 2026-06-13
+**Area:** `src/mesh` router stack (`NextHopRouter`, `ReliableRouter`, `FloodingRouter`, `Router`, `NodeDB`, `PacketHistory`)
+**Constraint:** No over-the-air / wire-format changes — `next_hop` and `relay_node` stay 1 byte, no `PacketHeader` changes, no breaking protobuf changes. All new state is RAM-only.
+
+This document captures the analysis and the proposed mitigations so the work can be
+continued on this branch by anyone. It is intentionally code-grounded (file:line
+references throughout) and standalone — you should not need the original investigation
+context to pick it up.
+
+---
+
+## TL;DR
+
+NextHop routing for direct messages (DMs) is unreliable on dense meshes. The headline
+cause is the **birthday problem**: `next_hop` and `relay_node` are each a single byte
+(the last byte of a 32-bit node number), so on a mesh of N nodes the probability that
+two share the same byte hits ~50% at **~19 nodes** and is near-certain by 50–100. But
+there are **other, equally important issues**: that single byte is trusted blindly at
+five different code sites, learned routes **never decay**, routes are learned from the
+**reverse (ACK) path** (asymmetric-link hazard), and collision-driven spurious
+rebroadcasts **amplify congestion** exactly when the mesh is busy.
+
+Because we can't widen the on-wire field, the fix is **interpretation-side** ("don't
+trust a byte that doesn't map to a unique reachable neighbor — flood instead") plus
+**recovery-side** ("decay stale/failing routes so they get re-discovered"). Four
+mitigations, M1–M4, all RAM-only. The net behavioral change: on dense/mobile meshes a
+DM that today silently misroutes or black-holes instead falls back to managed flooding
+(which still delivers) and re-learns a fresh route quickly. Sparse-mesh happy paths are
+unchanged.
+
+---
+
+## How NextHop routing works today (mechanics)
+
+Inheritance chain: `Router` → `FloodingRouter` → `NextHopRouter` → `ReliableRouter`.
+
+**The single-byte identifiers.** Both routing bytes come from one helper:
+
+```cpp
+// src/mesh/NodeDB.h:255
+uint8_t getLastByteOfNodeNum(NodeNum num) { return (uint8_t)((num & 0xFF) ? (num & 0xFF) : 0xFF); }
+```
+
+It projects a 32-bit node number onto 255 values (`0x00` is remapped to `0xFF` so it
+never collides with the `0`-valued sentinels `NO_NEXT_HOP_PREFERENCE` / `NO_RELAY_NODE`,
+`src/mesh/MeshTypes.h:44-46`). `next_hop` and `relay_node` in the packet header are
+`uint8_t` (`src/mesh/mesh.pb.h`, comments "Last byte of the node number…"). The learned
+route stored per destination, `meshtastic_NodeInfoLite::next_hop`, is also a single byte
+(`src/mesh/generated/meshtastic/deviceonly.pb.h:83`).
+
+**Sending a DM** — `NextHopRouter::send` (`src/mesh/NextHopRouter.cpp:23`):
+
+1. `p->relay_node = getLastByteOfNodeNum(getNodeNum())` (mark ourselves as relayer).
+2. `p->next_hop = getNextHop(p->to, p->relay_node)` (`src/mesh/NextHopRouter.cpp:192`):
+   look up `nodeDB->getMeshNode(to)->next_hop`; return it unless it equals the relayer
+   byte; otherwise `NO_NEXT_HOP_PREFERENCE` (→ flood).
+
+**Relaying** — `NextHopRouter::perhapsRebroadcast` (`src/mesh/NextHopRouter.cpp:133`):
+rebroadcast iff `next_hop == NO_NEXT_HOP_PREFERENCE` (flood) **or**
+`next_hop == getLastByteOfNodeNum(getNodeNum())` (we are the addressed next hop)
+(`:147`). Each node only ever compares against **its own** byte.
+
+**Learning** — `NextHopRouter::sniffReceived` (`src/mesh/NextHopRouter.cpp:89`): on an
+ACK/reply (`request_id`/`reply_id` set), if the relayer of the ACK was also a relayer of
+the original packet (validated via `PacketHistory::checkRelayers`), set
+`origTx->next_hop = p->relay_node` (`:114`). I.e. the **forward** next-hop is learned
+from the **reverse** path's relayer.
+
+**Retransmission / fallback** — `NextHopRouter::doRetransmissions`
+(`src/mesh/NextHopRouter.cpp:284`). Budgets: `NUM_RELIABLE_RETX=3` (originator: initial
+
+- 2 retries), `NUM_INTERMEDIATE_RETX=2` (relayer: 1 retry). On the **last** retry
+  (`numRetransmissions==1`) it resets `next_hop` to `NO_NEXT_HOP_PREFERENCE` on the packet
+  **and** clears `sentTo->next_hop` in NodeDB, then floods (`:313-321`). Retransmit timing
+  comes from `iface->getRetransmissionMsec`, whose contention window **grows with channel
+  utilization** (`src/mesh/RadioInterface.cpp` `getTxDelayMsec`/`getTxDelayMsecWeighted`).
+
+**Dedup / relayer history** — `PacketHistory` (`src/mesh/PacketHistory.cpp`): a bounded
+ring (`PACKETHISTORY_MAX = max(MAX_NUM_NODES*2, 100)`, 20 B/record) keyed by
+`(sender,id)`, tracking up to `NUM_RELAYERS=6` relayer **bytes** per packet in
+`relayed_by[]`. `wasRelayer` (`:490`) and `checkRelayers` (`:517`) match bytes against
+that array.
+
+---
+
+## Root-cause analysis
+
+### 1. The single byte is trusted blindly at five sites (the birthday problem)
+
+| #   | Site                             | File:line                   | Failure on collision                                                                                                      |
+| --- | -------------------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| 1   | Rebroadcast self-check           | `NextHopRouter.cpp:147`     | A remote "impostor" node sharing the intended next-hop's byte also rebroadcasts → wasted airtime / congestion.            |
+| 2   | Route learning                   | `NextHopRouter.cpp:111-114` | Stores an ambiguous byte as the route; later resolves to the wrong physical node.                                         |
+| 3   | Relayer validation               | `PacketHistory.cpp:490-538` | `wasRelayer(byte)` returns true for the wrong node → mis-validated ACK / mis-learn.                                       |
+| 4   | Favorite-router hop preservation | `Router.cpp:120-145`        | **First** NodeDB node whose last byte matches wins — non-deterministic; can preserve hops for the wrong relay (hop leak). |
+| 5   | Send-path lookup                 | `NextHopRouter.cpp:192-207` | Emits a byte that may address the wrong node; no check it still maps to a reachable neighbor.                             |
+
+Collision math (uniform last byte over 255 buckets): P(collision) ≈ 50% at ~19 nodes,
+
+> 99% by ~75 nodes. Dense meshes are squarely in the "always colliding" regime.
+
+### 2. Stale routes never decay
+
+The learned `next_hop` byte is cleared only on the **current DM's** last retry
+(`NextHopRouter.cpp:313-321`). A route learned hours ago that has since gone dead is
+still trusted on the **next** DM's first attempt — which on a congested mesh is also the
+slowest attempt. Result: silent black-hole at a dead hop until the retransmission budget
+drains, then a late flood. Intermediate nodes hold stale routes indefinitely.
+
+### 3. Reverse-path (asymmetric-link) learning
+
+`origTx->next_hop` is learned from the ACK's relayer (`NextHopRouter.cpp:110-114`) — the
+**reverse** direction. RF links are frequently asymmetric, so the best reverse relay can
+be a poor forward relay. Worse, the next reverse ACK immediately re-learns the same bad
+hop, so the route **flaps** back to the bad value even after a failure reset.
+
+### 4. Congestion amplification
+
+Collision-driven impostor rebroadcasts (issue 1) add airtime; the contention window
+grows with channel utilization, so retransmit intervals **lengthen** exactly when the
+mesh is busy. The 3-try reliable budget can then expire before delivery. On dense
+meshes, efficiency _is_ reliability.
+
+### Note: pubkey-derived node numbers (develop / 2.8) — does not change the plan
+
+develop derives the node number from the public key:
+`my_node_num = crc32Buffer(public_key)` (`src/mesh/NodeDB.cpp:481`), re-derived on key
+change in `createNewIdentity()` (`src/mesh/NodeDB.cpp:3113`). This **reinforces** the
+plan rather than changing it:
+
+- **Birthday problem unchanged and now textbook-exact.** CRC32 mixes well → the last
+  byte is uniformly distributed over 256 values. Derivation adds no wire bits.
+- **Node numbers are now immutable / identity-bound.** Pre-2.8 `pickNewNodeNum()` could
+  renumber a node to dodge a conflict; now the number is fixed by the key, so a last-byte
+  collision **cannot be resolved operationally by renumbering** → M1/M2/M3 become _more_
+  necessary.
+- **Resolver gets cleaner inputs.** Stable node numbers keep a learned byte bound to one
+  identity (good for M3 freshness). `createNewIdentity()` retires the old entry by marking
+  it **ignored** and clearing its pubkey (`src/mesh/NodeDB.cpp:3123-3125`), which M1's
+  candidate gate already skips — so key rotation can't pollute resolution.
+- **No wire-free disambiguation unlocked.** A receiver still gets only 1 byte and cannot
+  recover which full node number a colliding value meant — so "detect ambiguity → flood"
+  remains the correct strategy.
+
+---
+
+## Proposed mitigations
+
+Key insight for all of M1/M2: **a 1-byte ID only needs to be unique among a node's
+direct neighbors / plausible relays, not the whole mesh.** That candidate set is small
+(typically 5–15), so a byte usually resolves unambiguously there; when it doesn't, fall
+back to the _safe_ behavior (flood / decrement / don't-learn).
+
+### M1 — Ambiguity-aware last-byte resolution (new NodeDB primitive)
+
+New types + methods in `src/mesh/NodeDB.h` (near line 255) / `src/mesh/NodeDB.cpp`
+(near `getMeshNode`, ~2936):
+
+```cpp
+enum class LastByteResolution : uint8_t { None, Unique, Ambiguous };
+struct ResolvedNode { LastByteResolution status = LastByteResolution::None; NodeNum num = 0; };
+
+// Resolve a single on-wire last-byte to a unique full NodeNum among relevant candidates.
+ResolvedNode resolveLastByte(uint8_t lastByte, bool requireDirectNeighbor);
+// Convenience: true iff exactly one relevant candidate (Ambiguous and None both -> false = SAFE).
+bool resolveUniqueLastByte(uint8_t lastByte, bool requireDirectNeighbor, NodeNum *outNum = nullptr);
+```
+
+- **One linear pass** over `meshNodes`, reusing `getNumMeshNodes()`/`getMeshNodeByIndex()`,
+  the bitfield helpers (`nodeInfoLiteIsFavorite/HasUser/IsIgnored`), `sinceLastSeen()`,
+  and `getLastByteOfNodeNum()`. **Early-exit** on the 2nd match (return `Ambiguous`).
+- **Guard:** `if (lastByte == 0) return {None, 0};` (covers `NO_RELAY_NODE` / MQTT-invalid).
+- **Candidate gate** (skip): `num == getNodeNum()` (never resolve to ourselves), `num == 0`,
+  `num == NODENUM_BROADCAST`, `nodeInfoLiteIsIgnored`. Then match
+  `getLastByteOfNodeNum(node->num) == lastByte` (cheapest test last, mirroring `Router.cpp:119`).
+- **Relevance gate:**
+  - `requireDirectNeighbor == true` (strict, for SEND): `has_hops_away && hops_away == 0`
+    **and** `sinceLastSeen(node) < NEXTHOP_NEIGHBOR_FRESH_SECS`.
+  - `requireDirectNeighbor == false` (lenient, for learn / hop-preserve): accept if direct
+    neighbor **or** `nodeInfoLiteIsFavorite` **or** role ∈ {ROUTER, ROUTER_LATE, CLIENT_BASE}.
+- **No tie-break.** A collision must return `Ambiguous` — picking "best SNR" would
+  resurrect the silent-misroute bug. (Deliberate non-goal; document in code.)
+
+New constant in `src/mesh/MeshTypes.h` (near line 44):
+`#define NEXTHOP_NEIGHBOR_FRESH_SECS (60 * 60 * 2)` (mirrors `NUM_ONLINE_SECS`).
+
+### M2 — Only route on bytes that resolve to a unique, reachable neighbor
+
+In `getNextHop` (`src/mesh/NextHopRouter.cpp:192-207`), after the existing split-horizon
+check (`node->next_hop != relay_node`), require the stored byte to resolve to a **unique,
+currently-fresh direct neighbor**; else flood:
+
+```cpp
+if (node->next_hop != relay_node) {
+    ResolvedNode r = nodeDB->resolveLastByte(node->next_hop, /*requireDirectNeighbor=*/true);
+    if (r.status == LastByteResolution::Unique) return node->next_hop;
+    LOG_WARN("Next hop 0x%x for 0x%x %s -> flood", node->next_hop, to,
+             r.status == LastByteResolution::Ambiguous ? "ambiguous among neighbors" : "no longer a neighbor");
+    return std::nullopt;
+}
+```
+
+This self-heals when a neighbor goes away (unicast-into-a-void becomes a flood). It
+applies to originating, relaying, and retrying, since all route through `getNextHop`.
+
+Apply M1's safe fallback at the other sites:
+
+- **Learning** (`NextHopRouter.cpp:111-114`): gate `origTx->next_hop = p->relay_node` on
+  `resolveUniqueLastByte(p->relay_node, /*direct=*/false)`. Ambiguous/unknown → don't
+  learn (leave route unset → flood).
+- **Favorite-router preservation** (`Router.cpp:120-145`): replace the "first match wins"
+  loop with `resolveUniqueLastByte(p->relay_node, /*direct=*/false)` + a re-check that the
+  resolved node is favorite/has_user/router. Ambiguous/none/not-favorite → **decrement**
+  (safe). Net: removes one full DB scan, adds one resolver scan (wash).
+
+**Left unchanged, by design (document why in code):**
+
+- **Site 1** rebroadcast self-check (`NextHopRouter.cpp:147`) and self-identity checks
+  (`ReliableRouter.cpp:127`): a node matches its **own** byte — no DB resolution helps. A
+  remote impostor sharing the intended next-hop's byte will still rebroadcast. M1/M2
+  shrink the blast radius by reducing how often an ambiguous byte is ever stored or
+  originated; a true fix needs a wider field (out of scope). **This is the one residual
+  the plan cannot fully close.**
+- **Site 3** `wasRelayer`/`checkRelayers` (`PacketHistory.cpp:490-538`): intentionally
+  byte-domain (both sides are on-wire bytes); the consumer (learning) is now hardened.
+  Add a one-line comment; do not change.
+
+### M3 — Route freshness / failure memory (RAM table on NextHopRouter)
+
+A bounded, LRU-evicted table keyed by destination, mirroring `PacketHistory`'s
+reuse-oldest discipline (not an unbounded map) to cap RAM.
+
+`src/mesh/NextHopRouter.h` (near `pending`, line 99):
+
+```cpp
+struct RouteHealth {
+    NodeNum dest = 0;                  // 0 == empty slot
+    uint32_t learnedAtMsec = 0;        // millis() at last (re)learn; rollover-aware
+    uint8_t consecutiveFailures = 0;
+    uint8_t lastNextHop = NO_NEXT_HOP_PREFERENCE; // byte this health refers to
+};
+static constexpr uint8_t ROUTE_HEALTH_MAX = 32;   // ~384B; drop to 16 if RAM-tight
+RouteHealth routeHealth[ROUTE_HEALTH_MAX] = {};
+// Helpers take `now` (pure/testable): findRouteHealth, getOrAllocRouteHealth,
+// noteRouteLearned, noteRouteSuccess, noteRouteFailure, isRouteStale, clearRouteHealth
+```
+
+Policy:
+
+| Constant                  | Value  | Rationale                                                                                                                                              |
+| ------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `ROUTE_TTL_MSEC`          | 30 min | Survives a normal conversation; re-discovers a moved node within a telemetry interval.                                                                 |
+| `ROUTE_FAILURE_THRESHOLD` | 3      | 1–2 consecutive failures are transient LoRa collisions; 3 to the same hop = dead. Accumulates **across** DMs (independent of the per-DM 3-try budget). |
+
+`isRouteStale(h, now)` = `(now - h.learnedAtMsec) >= ROUTE_TTL_MSEC || h.consecutiveFailures >= ROUTE_FAILURE_THRESHOLD`.
+All age math uses **unsigned subtraction** (rollover-safe, matching
+`PacketHistory.cpp:364`); treat `learnedAtMsec == 0` as "set now".
+
+Wiring (as built — `src/mesh/NextHopRouter.cpp`, `src/mesh/ReliableRouter.cpp`):
+
+- `getNextHop`: if a health record matches the stored byte and `isRouteStale`, clear
+  `node->next_hop` (NodeDB) **and** `clearRouteHealth`, return `nullopt` (flood). No
+  record yet (cold path, first DM after boot) → trust NodeDB, but the M2 strict-neighbor
+  gate still applies.
+- `sniffReceived` learn: gate the write through `resolveUniqueLastByte` (M2), then
+  `noteRouteLearned(p->from, p->relay_node, millis())` — resets `consecutiveFailures`
+  **only if the hop changed** (anti-flap for asymmetric re-learn); otherwise just refreshes
+  `learnedAtMsec`. (No success signal is taken on the intermediate reverse-pass: an ACK
+  merely passing through us is not proof that _we_ delivered, and resetting failures there
+  would reintroduce the asymmetric flap.)
+- `doRetransmissions`: on the last-retransmission branch (`numRetransmissions == 1`, the
+  point a directed delivery has gone un-ACKed for both originator and intermediate) →
+  `noteRouteFailure(to)`, then the existing NodeDB `next_hop` reset + flood. We deliberately
+  do **not** `clearRouteHealth` here: keeping the record is what lets the failure count
+  accumulate across DMs so a flapping reverse-path-relearned dead hop eventually ages out.
+- `ReliableRouter::sniffReceived` ACK path → `noteRouteSuccess(getFrom(p), millis())`
+  (an end-to-end ACK addressed to us is genuine forward-delivery proof; clears failures and
+  refreshes freshness). `noteRouteSuccess`/`noteRouteFailure` are no-ops when no record
+  exists, so flood-only destinations never pollute the table.
+
+**Reconciliation (no double-handling):** `doRetransmissions` owns _in-flight_ failure of
+the current DM (reset NodeDB `next_hop` + flood, and bump the cross-DM failure counter);
+`getNextHop` owns _between-DM_ staleness (TTL or failure-threshold → flood + clear). The
+only place that erases a health record is the `getNextHop` decay path; the retransmission
+path leaves it intact so the counter survives a reverse-path re-learn.
+
+### M4 — Earlier flood for unverified routes (gated, off by default)
+
+Compile-gated so healthy sparse meshes are untouched. **Default is off** — the define
+lives in `NextHopRouter.h` and must be flipped to measure:
+`#define NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED 1`.
+
+In `doRetransmissions`, the directed-retry `else` branch: if the route is **not verified**
+(`!findRouteHealth(to) || consecutiveFailures > 0 || isRouteStale`), reset `next_hop` and
+flood on this attempt instead of spending another directed try. A **verified** route
+(record present, `consecutiveFailures == 0`, within TTL — i.e. recently ACKed) takes the
+unchanged directed-retry path, so the sparse-mesh happy path is untouched. Trade-off:
+airtime ↔ latency; the gate ensures we never pay the flood cost on a proven route, only on
+one we already distrust. Off by default precisely so it can be A/B-measured on the
+simulator before broad enable.
+
+---
+
+## Files to modify
+
+| File                                        | Change                                                                                                                                               |
+| ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/mesh/MeshTypes.h`                      | `NEXTHOP_NEIGHBOR_FRESH_SECS`, `ROUTE_TTL_MSEC`, `ROUTE_FAILURE_THRESHOLD`, `NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED`                                      |
+| `src/mesh/NodeDB.h` / `src/mesh/NodeDB.cpp` | `LastByteResolution`, `ResolvedNode`, `resolveLastByte`, `resolveUniqueLastByte`                                                                     |
+| `src/mesh/NextHopRouter.h`                  | `RouteHealth` + array + helpers; `#ifdef PIO_UNIT_TESTING public:` for helpers and `getNextHop`                                                      |
+| `src/mesh/NextHopRouter.cpp`                | `getNextHop` (M2 gate + M3 decay); `sniffReceived` (learn gate + health seed + success); `doRetransmissions` (failure counting + M4); comment site 1 |
+| `src/mesh/Router.cpp`                       | `shouldDecrementHopLimit` → resolver + favorite/router re-check                                                                                      |
+| `src/mesh/ReliableRouter.cpp`               | ACK path → `noteRouteSuccess`                                                                                                                        |
+| `test/test_nexthop_routing/test_main.cpp`   | **new** unit suite (auto-built under `[env:native]`)                                                                                                 |
+
+**Reuse, don't reinvent:** `getLastByteOfNodeNum`, `sinceLastSeen`, the bitfield helpers,
+`getMeshNodeByIndex`/`getNumMeshNodes`, PacketHistory's reuse-oldest eviction shape, and
+`MockNodeDB::addTestNode` (from `test/test_hop_scaling/test_main.cpp`).
+
+---
+
+## Edge cases
+
+- **`0x00`↔`0xFF` projection:** the resolver compares via `getLastByteOfNodeNum` on both
+  sides, so a `…00` node and a `…FF` node correctly collide on `0xFF` → `Ambiguous`. Test
+  explicitly.
+- **MQTT packets:** `relay_node`/`next_hop` are forced invalid when `hop_start == 0`
+  (`src/mesh/RadioLibInterface.cpp:603-605`) → byte 0 → resolver `None` → don't learn
+  (correct).
+- **`has_hops_away == false`** nodes are excluded from the strict gate (never fabricate a
+  Unique neighbor for M2); admitted to the lenient gate only via favorite/router role.
+  Safe; self-corrects once `hops_away` is learned.
+- **Self / broadcast:** the resolver skips `getNodeNum()` and `NODENUM_BROADCAST`;
+  `getNextHop` already early-returns for broadcast.
+- **Perf:** M2 adds one O(N) resolver scan per directed send/relay (early-exit on the 2nd
+  match), cheaper than the crypto already on that path; site-4 is a wash. If ever hot, a
+  future 256-entry last-byte index is the optimization (not now — RAM).
+
+---
+
+## Verification (all tiers)
+
+### 1. Native unit tests — new `test/test_nexthop_routing/test_main.cpp`
+
+`pio test -e native -f test_nexthop_routing`; on macOS `./bin/test-native-docker.sh -f test_nexthop_routing`.
+Design the RouteHealth helpers to take `now` as a parameter so the 30-min TTL logic is
+testable without a clock mock.
+
+- **Resolver:** None / Unique / **Ambiguous (birthday collision)** / strict-excludes-stale /
+  strict-excludes-far / lenient-includes-favorite-router / lenient-collision / skips-self /
+  skips-ignored / **`0x00`↔`0xFF` collision** / early-exit.
+- **`getNextHop`:** unique→byte, **ambiguous→nullopt**, stale-neighbor→nullopt,
+  split-horizon (relay==next_hop)→nullopt, broadcast→nullopt.
+- **RouteHealth:** TTL boundary, **rollover** (learn near `0xFFFFFFFF`, check after wrap),
+  failure threshold, success-resets, **re-learn-same-hop keeps fails (anti-flap)**,
+  re-learn-new-hop resets, LRU eviction bound, clear.
+- **Site-4:** preserve on unique favorite router; **decrement on two colliding favorites**;
+  decrement when the resolved node is not a favorite.
+- **Sparse-mesh regression:** all-distinct last bytes → every resolve Unique, `getNextHop`
+  returns the stored byte unchanged (proves no happy-path change).
+- Re-run `test_packet_history` and `test_hop_scaling` for no regression.
+
+### 2. portduino SimRadio simulator
+
+`pio run -e native && ./bin/test-simulator.sh`. Best vehicle for the **intermediate-node**
+path the 2-device bench can't reach. Line topology A — B — C: establish A→C (B learns a
+directed route), stop B relaying that dest, confirm A re-discovers via flood within
+`ROUTE_FAILURE_THRESHOLD` and that B's `noteRouteFailure`/`clearRouteHealth` fires (visible
+via the `LOG_INFO "Route to … stale"` / "Resetting next hop" lines). Use this to A/B M4
+(attempts-to-delivery, total airtime).
+
+### 3. Hardware via meshtastic MCP (auto-detect; 3+ devices for a real hop)
+
+- `mcp-server/tests/mesh/test_nexthop_multihop_recovery.py` — **the multi-hop validator
+  for this work** (added on this branch). Self-discovers an A — relay — C line, asserts a
+  directed DM is delivered across the relay (next_hop + M1/M2/M3 engaged), and asserts
+  delivery recovers after the relay is power-cycled (M3). Skips unless the bench is a true
+  multi-hop line (≥3 roles via `--hub-profile`, endpoints out of direct RF range).
+- `mcp-server/tests/mesh/test_direct_with_ack.py` — happy-path regression: a fresh/unique
+  route still delivers a want_ack DM on the first/second try (M4's gate must keep this
+  green).
+- `mcp-server/tests/mesh/test_peer_offline_recovery.py` — 2-device recovery validator: peer
+  off mid-conversation then back. Must stay green and ideally recover in fewer attempts.
+
+### 4. Build / format sanity
+
+native-macos **and** Docker both ways; trunk clang-format@16.0.3; a release `pio run` to
+confirm the `#ifdef PIO_UNIT_TESTING` visibility widening does **not** leak into
+production; sanity-check RAM headroom on the smallest nRF52 build for the ~384 B table.
+
+---
+
+## Verification status (as built on `nexthop-redux`)
+
+| Tier                             | What ran                                                                            | Result              |
+| -------------------------------- | ----------------------------------------------------------------------------------- | ------------------- |
+| Unit (native-macos)              | `test_nexthop_routing` (31 cases)                                                   | ✅ 31/31            |
+| Unit (Docker / Linux, CI parity) | `test_nexthop_routing`                                                              | ✅ 31/31            |
+| Regression                       | `test_packet_history`, `test_hop_scaling`, `test_mqtt`, `test_traffic_management`   | ✅ 105/105          |
+| Build                            | `pio run -e native-macos` (M4 off) and with `-DNEXTHOP_EARLY_FLOOD_ON_UNVERIFIED=1` | ✅ both link        |
+| Format                           | trunk `clang-format@16.0.3`                                                         | ✅ no issues        |
+| Simulator (CI `simulator-tests`) | `meshtasticd -s` + `meshtastic.test.testSimulator()` on native-macos                | ✅ exit 0, no crash |
+
+**Pending (environment-blocked, not yet run):**
+
+- **Multi-hop A–B–C recovery sim** — the `simulator/` broker hub is **not git-tracked**
+  (only stale local `.pyc`), and two `meshtasticd -s` instances can't hear each other
+  without it. The intermediate-node failure-count path and the M4 A/B therefore have unit
+  coverage of their logic but no end-to-end multi-node run yet.
+- **Hardware / multi-hop tier** — a committable bench test now exists:
+  `mcp-server/tests/mesh/test_nexthop_multihop_recovery.py`. It self-discovers a real
+  multi-hop pair (A — relay — C), asserts a directed DM is delivered across the relay, and
+  asserts delivery recovers after the relay is power-cycled (the M3 path). It
+  `pytest.skip`s cleanly unless the bench is a true line with endpoints out of direct RF
+  range (≥3 roles via `--hub-profile`), so it's safe to commit and only asserts when the
+  NextHop path is genuinely exercised. Collected + verified to skip without hardware;
+  not yet run on a bench. `test_direct_with_ack.py` / `test_peer_offline_recovery.py`
+  remain the 2-device happy-path/recovery regressions.
+
+---
+
+## Risks & limitations
+
+- **Site-1 impostor rebroadcast** is unfixable without a wider field — documented; M1/M2
+  only shrink its frequency.
+- **Dense meshes flood DMs more often** — intended (a flooded DM arrives; a mis-unicast one
+  black-holes). Call out in the PR so reviewers expect a slightly higher DM flood rate on
+  very dense meshes.
+- **M4 airtime** if the gate is too loose → default conservative + compile-gated +
+  simulator A/B before broad enable.
+- **RAM** ~384 B (32 slots); 16 slots (~192 B) with graceful LRU degradation if tight.
+- **Asymmetric flap** not fully closed (a _new_ bad hop resets the counter); the TTL
+  backstop bounds it. Per-hop failure history is future work (more RAM).
+
+---
+
+## How to continue this work (commit sequencing)
+
+Each step is independently testable; land them as separate commits.
+
+1. **M1 resolver + unit tests** — `NodeDB` only; no behavior change until wired. Lands the
+   `resolveLastByte`/`resolveUniqueLastByte` primitive and its full unit-test matrix.
+2. **M2 + wiring + tests** — `getNextHop` strict gate, learning gate, favorite-router
+   preservation rewrite. Adds the `getNextHop` and site-4 tests.
+3. **M3 health table + decay + tests** — RAM `RouteHealth` table, decay-on-read, failure/
+   success accounting, reconciliation with the existing last-retry reset. Adds the
+   route-health unit tests and the simulator recovery check.
+4. **M4 gated tuning** — early-flood-on-unverified behind the compile flag; simulator A/B
+   and hardware regression.
+
+Reference plan (with the same content) was developed at
+`~/.claude/plans/nexthop-routing-for-direct-lexical-shell.md` on the author's machine; this
+in-repo doc is the canonical handoff copy.
@@ -0,0 +1,347 @@
+"""Multi-hop NextHop directed-message delivery + relay-recovery (bench test).
+
+This is the hardware/tier-3 validator for the NextHop DM reliability work
+(see `docs/nexthop-routing-reliability.md`). The unit suite
+`test/test_nexthop_routing` covers the routing *logic* exhaustively; this test
+covers the *end-to-end* multi-hop behavior that only a real (or RF-separated)
+mesh exercises:
+
+  * a directed DM that must traverse a relay is delivered (next_hop routing +
+    the M1/M2 ambiguity gate + M3 route learning all engage), and
+  * when the established relay drops and returns, delivery recovers rather than
+    black-holing (the M3 stale-route decay / re-learn path).
+
+TOPOLOGY REQUIREMENT — why this usually SKIPS:
+  A NextHop relay only happens when the two endpoints are NOT direct neighbors.
+  Three co-located radios all hear each other, so A→C is a single direct hop and
+  next_hop never engages. To run this test the bench must be a *line* — A — B — C
+  — with the endpoints out of each other's direct RF range (physical distance or
+  attenuators). The `multihop_topology` fixture detects this automatically: it
+  warms the mesh, looks for a pair that is ≥1 hop apart, confirms the relay via
+  traceroute, and `pytest.skip`s cleanly when the bench is all-direct. So this
+  file is safe to commit and run anywhere — it only *asserts* when the topology
+  genuinely requires a relay.
+
+REQUIREMENTS:
+  * ≥3 baked devices. The default hub profile is 2 roles (nrf52, esp32s3); add a
+    third via `--hub-profile=path/to/hub.yaml` (see conftest `hub_profile`).
+  * The relay-recovery test additionally needs uhubctl + a power-controllable
+    relay port (same gate the other power tests use).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import pytest
+from meshtastic_mcp.connection import connect
+from tests import _power
+from tests._port_discovery import resolve_port_by_role
+
+from ._receive import ReceiveCollector, nudge_nodeinfo, nudge_nodeinfo_port
+
+
+def _hops_away(rec: dict[str, Any]) -> int | None:
+    """Read a node's hop distance from a `nodesByNum` entry, tolerating either
+    the camelCase (`hopsAway`) or snake_case (`hops_away`) spelling depending on
+    the meshtastic-python version."""
+    for key in ("hopsAway", "hops_away"):
+        val = rec.get(key)
+        if isinstance(val, int):
+            return val
+    return None
+
+
+def _warm_mesh(ports: list[str], rounds: int = 2, settle: float = 6.0) -> None:
+    """Flood a fresh NodeInfo from every node so the whole mesh (including
+    multi-hop pairs, reached via relayed broadcasts) populates pubkeys and hop
+    distances. Best-effort — a single node failing to nudge shouldn't abort."""
+    for _ in range(rounds):
+        for port in ports:
+            try:
+                nudge_nodeinfo_port(port)
+            except Exception:  # noqa: BLE001 — warmup is best-effort
+                pass
+            time.sleep(0.5)
+        time.sleep(settle)
+
+
+def _wait_for_pubkey(
+    tx_iface: Any, rx_num: int, rx_port: str, deadline_s: float = 90.0
+) -> bool:
+    """Block until `tx_iface` holds `rx_num`'s public key (directed PKI sends
+    NAK without it). Re-nudges both sides periodically; multi-hop warmup is
+    slower than the 2-device case because NodeInfo must be relayed, hence the
+    longer default deadline."""
+    deadline = time.monotonic() + deadline_s
+    last_nudge = time.monotonic()
+    while time.monotonic() < deadline:
+        rec = (tx_iface.nodesByNum or {}).get(rx_num, {})
+        if rec.get("user", {}).get("publicKey"):
+            return True
+        if time.monotonic() - last_nudge > 20.0:
+            nudge_nodeinfo_port(rx_port)
+            nudge_nodeinfo(tx_iface)
+            last_nudge = time.monotonic()
+        time.sleep(1.0)
+    return False
+
+
+def _traceroute_route(tx_port: str, rx_num: int, rx_port: str) -> list[int] | None:
+    """Run a traceroute TX→RX and return the forward `route` (list of relay node
+    numbers), or None if it couldn't be obtained. Mirrors test_traceroute's
+    request/PKI/retry pattern."""
+    from meshtastic.mesh_interface import MeshInterface
+
+    with ReceiveCollector(tx_port, topic="meshtastic.receive.traceroute") as tx:
+        nudge_nodeinfo_port(rx_port)
+        tx.broadcast_nodeinfo_ping()
+        if not _wait_for_pubkey(tx._iface, rx_num, rx_port, 60.0):
+            return None
+        for _attempt in range(2):
+            try:
+                tx._iface.sendTraceRoute(dest=rx_num, hopLimit=5)
+                break
+            except MeshInterface.MeshInterfaceError:
+                time.sleep(5.0)
+        else:
+            return None
+        pkt = tx.wait_for(lambda p: p.get("from") == rx_num, timeout=8.0)
+        if pkt is None:
+            return None
+        tr = (pkt.get("decoded", {}) or {}).get("traceroute") or {}
+        return [int(n) for n in (tr.get("route") or [])]
+
+
+@pytest.fixture(scope="session")
+def multihop_topology(baked_mesh: dict[str, Any]) -> dict[str, Any]:
+    """Discover a real multi-hop pier (tx → relay → rx) on the bench, or skip.
+
+    Returns {tx_role, tx_port, rx_role, rx_port, rx_num, relay_role, relay_num}.
+    """
+    roles = sorted(baked_mesh)
+    if len(roles) < 3:
+        pytest.skip(
+            "multi-hop NextHop test needs ≥3 baked devices arranged as a line "
+            "(endpoints out of direct RF range). Add a third role via "
+            f"--hub-profile. Detected roles: {roles}"
+        )
+
+    by_role = {r: (baked_mesh[r]["port"], baked_mesh[r]["my_node_num"]) for r in roles}
+    if any(num is None for _, num in by_role.values()):
+        pytest.skip("a baked device is missing my_node_num; can't map the topology")
+
+    _warm_mesh([port for port, _ in by_role.values()])
+
+    # Find an ordered pair that is ≥1 hop apart, using each node's own nodeDB
+    # (cheap — no traceroute yet). On an all-direct bench nothing qualifies.
+    multihop_pair: tuple[str, str] | None = None
+    for a_role in roles:
+        a_port, _ = by_role[a_role]
+        try:
+            with connect(port=a_port) as a_iface:
+                nodes = a_iface.nodesByNum or {}
+        except Exception:  # noqa: BLE001
+            continue
+        for c_role in roles:
+            if c_role == a_role:
+                continue
+            _, c_num = by_role[c_role]
+            hops = _hops_away(nodes.get(c_num, {}))
+            if hops is not None and hops >= 1:
+                multihop_pair = (a_role, c_role)
+                break
+        if multihop_pair:
+            break
+
+    if not multihop_pair:
+        pytest.skip(
+            "no multi-hop pair found — every device appears to be a direct "
+            "neighbor. Arrange the bench as a line (A — B — C) with the "
+            "endpoints out of direct RF range (distance or attenuators) so a "
+            "relay is actually required, then re-run."
+        )
+
+    a_role, c_role = multihop_pair
+    a_port, _ = by_role[a_role]
+    c_port, c_num = by_role[c_role]
+
+    route = _traceroute_route(a_port, c_num, c_port)
+    if not route:
+        pytest.skip(
+            f"{a_role}→{c_role} looked multi-hop but traceroute returned no "
+            "intermediate relay; can't identify the relay node to drive the "
+            "recovery test"
+        )
+
+    relay_num = route[0]
+    relay_role = next((r for r in roles if by_role[r][1] == relay_num), None)
+    return {
+        "tx_role": a_role,
+        "tx_port": a_port,
+        "rx_role": c_role,
+        "rx_port": c_port,
+        "rx_num": c_num,
+        "relay_role": relay_role,
+        "relay_num": relay_num,
+    }
+
+
+@pytest.mark.timeout(300)
+def test_multihop_dm_delivers(multihop_topology: dict[str, Any]) -> None:
+    """A directed wantAck DM that must traverse the relay is delivered.
+
+    Exercises the NextHop routing path end-to-end: TX picks a next hop toward
+    RX (M2 gate), the relay resolves the next_hop byte and forwards (M1), and
+    the route is learned from the returning ACK (M3). Retries absorb transient
+    LoRa loss; the assertion is on eventual delivery.
+    """
+    tx_port = multihop_topology["tx_port"]
+    rx_port = multihop_topology["rx_port"]
+    rx_num = multihop_topology["rx_num"]
+    tx_role = multihop_topology["tx_role"]
+    rx_role = multihop_topology["rx_role"]
+    relay_role = multihop_topology["relay_role"]
+
+    unique = f"nexthop-mh-{tx_role}-to-{rx_role}-{int(time.time())}"
+
+    with ReceiveCollector(rx_port, topic="meshtastic.receive.text") as rx:
+        rx.broadcast_nodeinfo_ping()
+        with connect(port=tx_port) as tx_iface:
+            nudge_nodeinfo(tx_iface)
+            if not _wait_for_pubkey(tx_iface, rx_num, rx_port, 90.0):
+                pytest.skip(
+                    f"{tx_role} never learned {rx_role}'s pubkey over the relay; "
+                    "multi-hop PKI warmup didn't complete"
+                )
+            got = None
+            for _attempt in range(3):
+                pkt = tx_iface.sendText(unique, destinationId=rx_num, wantAck=True)
+                assert pkt is not None
+                got = rx.wait_for(
+                    lambda p: p.get("decoded", {}).get("text") == unique,
+                    timeout=45,
+                )
+                if got is not None:
+                    break
+                rx.broadcast_nodeinfo_ping()
+                nudge_nodeinfo(tx_iface)
+                time.sleep(5.0)
+
+    assert got is not None, (
+        f"multi-hop directed DM {tx_role}→{rx_role} via relay "
+        f"{relay_role!r} never landed — NextHop multi-hop delivery is broken"
+    )
+
+
+@pytest.mark.timeout(600)
+def test_multihop_relay_recovery(
+    multihop_topology: dict[str, Any],
+    power_cycle,  # noqa: ARG001 — forces the uhubctl-availability skip
+) -> None:
+    """Delivery recovers after the established relay drops and returns.
+
+    Establishes a baseline DM (route via relay learned), powers the relay OFF
+    (confirming TX survives sending across a downed relay), then powers it back
+    ON and asserts directed delivery resumes — the M3 stale-route decay /
+    re-learn path. With a strict A — B — C line there is no path while B is down,
+    so we only assert TX doesn't crash during the outage; the delivery assertion
+    is after B returns.
+    """
+    relay_role = multihop_topology["relay_role"]
+    if not relay_role:
+        pytest.skip(
+            "relay node isn't one of the baked hub roles, so it can't be "
+            "power-cycled; recovery test needs a controllable relay"
+        )
+
+    tx_port = multihop_topology["tx_port"]
+    rx_port = multihop_topology["rx_port"]
+    rx_num = multihop_topology["rx_num"]
+    tx_role = multihop_topology["tx_role"]
+    rx_role = multihop_topology["rx_role"]
+
+    base = f"mh-recover-base-{int(time.time())}"
+    post = f"mh-recover-post-{int(time.time())}"
+
+    # Baseline: confirm delivery works (so the route via the relay is learned)
+    # before we perturb anything — otherwise a later failure is ambiguous.
+    with ReceiveCollector(rx_port, topic="meshtastic.receive.text") as rx:
+        rx.broadcast_nodeinfo_ping()
+        with connect(port=tx_port) as tx_iface:
+            nudge_nodeinfo(tx_iface)
+            if not _wait_for_pubkey(tx_iface, rx_num, rx_port, 90.0):
+                pytest.skip("multi-hop PKI warmup failed; can't run recovery test")
+            tx_iface.sendText(base, destinationId=rx_num, wantAck=True)
+            assert (
+                rx.wait_for(
+                    lambda p: p.get("decoded", {}).get("text") == base, timeout=45
+                )
+                is not None
+            ), "baseline multi-hop delivery failed — skipping recovery to avoid a false result"
+
+    # Power the relay OFF.
+    try:
+        _power.power_off(relay_role)
+        _power.wait_for_absence(relay_role, timeout_s=15.0)
+    except Exception as exc:  # noqa: BLE001
+        try:
+            _power.power_on(relay_role)
+            resolve_port_by_role(relay_role, timeout_s=30.0)
+        except Exception:  # noqa: BLE001
+            pass
+        pytest.skip(f"can't power-control relay {relay_role!r}: {exc}")
+
+    # With the only relay down there's no path; we just confirm TX accepts the
+    # send and survives its internal retries (it must not crash / wedge).
+    try:
+        with connect(port=tx_port) as tx_iface:
+            pkt = tx_iface.sendText(
+                f"mh-while-down-{int(time.time())}",
+                destinationId=rx_num,
+                wantAck=True,
+            )
+            assert pkt is not None
+            time.sleep(8.0)  # let retransmissions + route decay run
+    except Exception as exc:  # noqa: BLE001 — restore bench state before failing
+        _power.power_on(relay_role)
+        resolve_port_by_role(relay_role, timeout_s=30.0)
+        raise AssertionError(
+            f"TX crashed sending across a downed relay: {exc}"
+        ) from exc
+
+    # Power the relay back ON and let it re-enumerate + boot.
+    _power.power_on(relay_role)
+    time.sleep(0.5)
+    try:
+        resolve_port_by_role(relay_role, timeout_s=30.0)
+    except Exception:  # noqa: BLE001 — relay port isn't one we connect to directly
+        pass
+    time.sleep(8.0)
+    _warm_mesh([tx_port, rx_port], rounds=1)  # re-flood so the relay re-learns
+
+    # Delivery should resume once the relay is back (M3 re-learn / decay path).
+    got = None
+    with ReceiveCollector(rx_port, topic="meshtastic.receive.text") as rx:
+        rx.broadcast_nodeinfo_ping()
+        with connect(port=tx_port) as tx_iface:
+            nudge_nodeinfo(tx_iface)
+            _wait_for_pubkey(tx_iface, rx_num, rx_port, 90.0)
+            for _attempt in range(4):
+                pkt = tx_iface.sendText(post, destinationId=rx_num, wantAck=True)
+                assert pkt is not None
+                got = rx.wait_for(
+                    lambda p: p.get("decoded", {}).get("text") == post,
+                    timeout=45,
+                )
+                if got is not None:
+                    break
+                rx.broadcast_nodeinfo_ping()
+                nudge_nodeinfo(tx_iface)
+                time.sleep(6.0)
+
+    assert got is not None, (
+        f"after relay {relay_role!r} returned, multi-hop DM {tx_role}→{rx_role} "
+        "never resumed — stale-route recovery (M3) may be broken"
+    )
@@ -200,6 +200,16 @@ lib_deps =
 	https://github.com/adafruit/Adafruit_TSL2561/archive/refs/tags/1.1.3.zip
 	# renovate: datasource=github-tags depName=BH1750_WE packageName=wollewald/BH1750_WE
 	https://github.com/wollewald/BH1750_WE/archive/refs/tags/1.1.10.zip
+	# renovate: datasource=github-tags depName=Sensirion Core packageName=sensirion/arduino-core
+	https://github.com/Sensirion/arduino-core/archive/refs/tags/0.7.3.zip
+	# renovate: datasource=github-tags depName=Sensirion I2C SCD4x packageName=sensirion/arduino-i2c-scd4x
+	https://github.com/Sensirion/arduino-i2c-scd4x/archive/refs/tags/1.1.0.zip
+	# renovate: datasource=github-tags depName=Sensirion I2C SFA3x packageName=sensirion/arduino-i2c-sfa3x
+	https://github.com/Sensirion/arduino-i2c-sfa3x/archive/refs/tags/1.0.0.zip
+	# renovate: datasource=github-tags depName=Sensirion I2C SCD30 packageName=sensirion/arduino-i2c-scd30
+	https://github.com/Sensirion/arduino-i2c-scd30/archive/refs/tags/1.0.0.zip
+	# renovate: datasource=github-tags depName=arduino-sht packageName=sensirion/arduino-sht
+	https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip

 ; Common environmental sensor libraries (not included in native / portduino)
 [environmental_extra_common]
@@ -218,16 +228,6 @@ lib_deps =
 	closedcube/ClosedCube OPT3001@1.1.2
 	# renovate: datasource=git-refs depName=meshtastic-DFRobot_LarkWeatherStation packageName=https://github.com/meshtastic/DFRobot_LarkWeatherStation gitBranch=master
 	https://github.com/meshtastic/DFRobot_LarkWeatherStation/archive/4de3a9cadef0f6a5220a8a906cf9775b02b0040d.zip
-	# renovate: datasource=github-tags depName=Sensirion Core packageName=sensirion/arduino-core
-	https://github.com/Sensirion/arduino-core/archive/refs/tags/0.7.3.zip
-	# renovate: datasource=github-tags depName=Sensirion I2C SCD4x packageName=sensirion/arduino-i2c-scd4x
-	https://github.com/Sensirion/arduino-i2c-scd4x/archive/refs/tags/1.1.0.zip
-	# renovate: datasource=github-tags depName=Sensirion I2C SFA3x packageName=sensirion/arduino-i2c-sfa3x
-	https://github.com/Sensirion/arduino-i2c-sfa3x/archive/refs/tags/1.0.0.zip
-	# renovate: datasource=github-tags depName=Sensirion I2C SCD30 packageName=sensirion/arduino-i2c-scd30
-	https://github.com/Sensirion/arduino-i2c-scd30/archive/refs/tags/1.0.0.zip
-	# renovate: datasource=github-tags depName=arduino-sht packageName=sensirion/arduino-sht
-	https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip

 ; Environmental sensors with BSEC2 (Bosch proprietary IAQ)
 [environmental_extra]
@@ -7,6 +7,7 @@
 #include "memGet.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
 #include <assert.h>
+#include <atomic>
 #include <cstring>
 #include <memory>
 #include <stdexcept>
@@ -20,6 +21,22 @@
 #if HAS_NETWORKING
 extern meshtastic::Syslog syslog;
 #endif
+
+namespace
+{
+std::atomic<bool> serialHalLogSuppressed{false};
+}
+
+void RedirectablePrint::setSerialHalLogSuppressed(bool suppressed)
+{
+    serialHalLogSuppressed.store(suppressed);
+}
+
+bool RedirectablePrint::isSerialHalLogSuppressed()
+{
+    return serialHalLogSuppressed.load();
+}
+
 void RedirectablePrint::rpInit()
 {
 #ifdef HAS_FREE_RTOS
@@ -281,6 +298,10 @@ meshtastic_LogRecord_Level RedirectablePrint::getLogLevel(const char *logLevel)
 void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 {

+    if (isSerialHalLogSuppressed()) {
+        return;
+    }
+
    // append \n to format
    size_t len = strlen(format);
    auto newFormat = std::unique_ptr<char[]>(new char[len + 2]);
@@ -24,6 +24,11 @@ class RedirectablePrint : public Print
  public:
    explicit RedirectablePrint(Print *_dest) : dest(_dest) {}

+    /// Suppress all log output while a SerialHal transaction is in progress.
+    // Unclear if this is necessary, but it seems to help with response speeds.
+    static void setSerialHalLogSuppressed(bool suppressed);
+    static bool isSerialHalLogSuppressed();
+
    /**
     * Set a new destination
     */
@@ -1056,8 +1056,12 @@ void setup()
 #endif
 #endif

-    auto rIf = initLoRa();
-
+    std::unique_ptr<RadioInterface> rIf;
+    if (!config.lora.serial_hal_only) {
+        rIf = initLoRa();
+    } else {
+        LOG_INFO("skipping LoRa radio init, for serialHal");
+    }
    lateInitVariant(); // Do board specific init (see extra_variants/README.md for documentation)

 #if !MESHTASTIC_EXCLUDE_MQTT
@@ -1101,10 +1105,9 @@ void setup()

    // Start airtime logger thread.
    airTime = new AirTime();
-
-    if (!rIf)
+    if (!rIf && !config.lora.serial_hal_only)
        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_NO_RADIO);
-    else {
+    else if (rIf) {
        // Log bit rate to debug output
        LOG_DEBUG("LoRA bitrate = %f bytes / sec", (float(meshtastic_Constants_DATA_PAYLOAD_LEN) /
                                                    (float(rIf->getPacketTime(meshtastic_Constants_DATA_PAYLOAD_LEN)))) *
@@ -440,6 +440,24 @@ bool Channels::usesPublicKey(ChannelIndex chIndex)
    return (psk.size == sizeof(defaultpsk) && memcmp(psk.bytes, defaultpsk, sizeof(defaultpsk) - 1) == 0);
 }

+bool Channels::isWellKnownChannel(ChannelIndex chIndex)
+{
+    const auto &ch = getByIndex(chIndex);
+    // Absent (unencrypted) or single-byte PSK — all the well-known key indexes
+    if (ch.settings.psk.size > 1)
+        return false;
+
+    const char *name = getName(chIndex);
+    for (int p = _meshtastic_Config_LoRaConfig_ModemPreset_MIN; p <= _meshtastic_Config_LoRaConfig_ModemPreset_MAX; p++) {
+        const char *presetName =
+            DisplayFormatters::getModemPresetDisplayName(static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(p), false, true);
+        // Presets without a display name fall through to "Invalid" — never a match
+        if (strcmp(presetName, "Invalid") != 0 && strcmp(name, presetName) == 0)
+            return true;
+    }
+    return false;
+}
+
 bool Channels::hasDefaultChannel()
 {
    // If we don't use a preset or the default frequency slot, or we override the frequency, we don't have a default channel
@@ -88,6 +88,12 @@ class Channels

    // Returns true if this channel's effective key is publicly decryptable (open or well-known/default PSK).
    bool usesPublicKey(ChannelIndex chIndex);
+    // Returns true if the channel is "well known": its PSK is absent or a
+    // single-byte well-known key index, AND its name is any modem-preset
+    // display name (e.g. a channel named "LongFast" counts even while the
+    // radio runs MediumFast). Broader than isDefaultChannel, which only
+    // matches the current preset's name and PSK byte 1.
+    bool isWellKnownChannel(ChannelIndex chIndex);

    // Returns true if we can be reached via a channel with the default settings given a region and modem preset
    bool hasDefaultChannel();
@@ -18,6 +18,9 @@
 #define default_telemetry_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 60 * 60)
 #define default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 60 * 60)
 #define default_broadcast_smart_minimum_interval_secs 5 * 60
+// Floor for our own position broadcasts when stationary (unchanged beyond the broadcast
+// precision) or fixed_position: identical positions get deduped by traffic management anyway.
+#define default_position_stationary_broadcast_secs (12 * 60 * 60)
 #define min_default_broadcast_interval_secs IF_ROUTER(ONE_DAY / 2, 60 * 60)
 #define min_default_broadcast_smart_minimum_interval_secs 5 * 60
 #define default_wait_bluetooth_secs IF_ROUTER(1, 60)
@@ -34,8 +37,14 @@
 enum class TrafficType { POSITION, TELEMETRY };

 // Traffic management defaults
-#define default_traffic_mgmt_position_precision_bits 24               // ~10m grid cells
-#define default_traffic_mgmt_position_min_interval_secs (ONE_DAY / 2) // 12 hours between identical positions
+#define default_traffic_mgmt_position_precision_bits 19                // ~90m grid cells (±45m)
+#define default_traffic_mgmt_position_min_interval_secs (11 * 60 * 60) // 11 hours between identical positions
+// Role cap: tracker-role origins may refresh a duplicate position this often (vs the 11h default).
+#define default_traffic_mgmt_tracker_position_min_interval_secs (60 * 60) // 1 hour
+// Role cap: lost-and-found origins may refresh a duplicate position this often, so a lost
+// device updates frequently without flooding. (Quantised to the dedup tick: ~2 ticks.)
+// Unlike before, lost-and-found is NOT exempt from the relayed precision clamp.
+#define default_traffic_mgmt_lost_and_found_position_min_interval_secs (15 * 60) // 15 minutes

 // Hop scaling defaults
 #define default_hop_scaling_min_target_nodes 40          // walk threshold: first hop reaching this cumulative count
@@ -88,6 +88,11 @@ extern const RegionInfo *myRegion;
 extern void initRegion();
 extern const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code);

+// Fill `map` with the region->valid-preset table, grouped so regions sharing a
+// preset list reference the same group. Sent to clients during want_config so
+// their UI can block illegal region+preset combinations.
+extern void getRegionPresetMap(meshtastic_LoRaRegionPresetMap &map);
+
 // Valid LoRa spread factor range and defaults
 constexpr uint8_t LORA_SF_MIN = 5;
 constexpr uint8_t LORA_SF_MAX = 12;
@@ -45,6 +45,11 @@ enum RxSource {
 // For old firmware there is no relay node set
 #define NO_RELAY_NODE 0

+// How recently we must have heard a direct neighbor for its single-byte relay id to be trusted as a
+// unique next hop. Mirrors NUM_ONLINE_SECS (NodeDB.cpp). Used by NodeDB::resolveLastByte() to scope
+// last-byte collision resolution to currently-reachable neighbors.
+#define NEXTHOP_NEIGHBOR_FRESH_SECS (60 * 60 * 2) // 2 hrs
+
 typedef int ErrorCode;

 /// Alloc and free packets to our global, ISR safe pool
@@ -98,21 +98,38 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
        // destination
        if (p->from != 0) {
            meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
-            if (origTx) {
-                // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
-                // directly from the destination
-                // Single lookup for both relayer checks on the same (request_id, to) pair
-                bool wasAlreadyRelayer = false;
-                bool weWereSoleRelayer = false;
-                bool weWereRelayer = false;
-                checkRelayers(p->relay_node, ourRelayID, p->decoded.request_id, p->to, &wasAlreadyRelayer, &weWereRelayer,
-                              &weWereSoleRelayer);
-                if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
-                    if (origTx->next_hop != p->relay_node) { // Not already set
+            // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
+            // directly from the destination. checkRelayers is read-only on PacketHistory and O(1), so we run it even
+            // when origTx is absent — that lets us still capture the confirmed hop into the TMM overflow cache below.
+            // Single lookup for both relayer checks on the same (request_id, to) pair
+            bool wasAlreadyRelayer = false;
+            bool weWereSoleRelayer = false;
+            bool weWereRelayer = false;
+            checkRelayers(p->relay_node, ourRelayID, p->decoded.request_id, p->to, &wasAlreadyRelayer, &weWereRelayer,
+                          &weWereSoleRelayer);
+            if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
+                // M1/M2: only learn a next hop whose last byte maps to a single plausible relay. On a dense
+                // mesh the byte may be ambiguous; storing it would aim future DMs at the wrong node. This gate
+                // now protects BOTH the hot-store route (NodeInfoLite.next_hop) AND the TMM overflow cache —
+                // the overflow cache deliberately holds many more next-hop bytes (long-tail nodes), so it is
+                // even more collision-prone and must never store an ambiguous byte either. Ambiguous/unknown
+                // -> store nothing and keep flooding (safe).
+                if (nodeDB->resolveUniqueLastByte(p->relay_node, /*requireDirectNeighbor=*/false)) {
+                    if (origTx && origTx->next_hop != p->relay_node) { // Not already set
                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
                                 p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
                        origTx->next_hop = p->relay_node;
                    }
+                    noteRouteLearned(p->from, p->relay_node, millis()); // M3: anchor freshness (hot or overflow route)
+#if HAS_TRAFFIC_MANAGEMENT
+                    // Mirror the confirmed (and now unique-resolved) hop into the TMM overflow cache so it
+                    // survives even when the source isn't (or is no longer) in the hot NodeDB.
+                    if (trafficManagementModule)
+                        trafficManagementModule->setNextHop(p->from, p->relay_node);
+#endif
+                } else {
+                    LOG_DEBUG("Not learning next hop for 0x%x: relay byte 0x%x ambiguous/unknown; keep flooding", p->from,
+                              p->relay_node);
                }
            }
        }
@@ -144,6 +161,11 @@ bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
    if (!isToUs(p) && !isFromUs(p) && (p->hop_limit > 0 || exhaustHops)) {
        if (p->id != 0) {
            if (isRebroadcaster()) {
+                // NOTE: this is a self-identity match (is the addressed next_hop OUR last byte?), so it
+                // cannot be hardened with resolveLastByte() — a remote node that legitimately shares our
+                // last byte will also match here and rebroadcast. That residual collision needs a wider
+                // on-wire field to fix. M1/M2 instead shrink the blast radius by reducing how often an
+                // ambiguous next_hop byte is ever learned (sniffReceived) or originated (getNextHop).
                if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
                    meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
                    LOG_INFO("Rebroadcast received message coming from %x", p->relay_node);
@@ -194,15 +216,63 @@ std::optional<uint8_t> NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
    if (isBroadcast(to))
        return std::nullopt;

+    // Hot store first: a direct array hit on the live NodeDB entry.
    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(to);
    if (node && node->next_hop) {
+        // M3: proactively decay a stale or repeatedly-failing route back to flooding, so a dead hop
+        // isn't trusted on the next DM's first (and on dense meshes, slowest) attempt. We only act on
+        // a health record that still matches the stored byte; a next_hop set by another path (e.g.
+        // TraceRouteModule) with no matching record is left authoritative.
+        const RouteHealth *h = findRouteHealth(to);
+        if (h && h->lastNextHop == node->next_hop && isRouteStale(*h, millis())) {
+            LOG_INFO("Next hop 0x%x for 0x%x is stale (age/fails); flood and clear", node->next_hop, to);
+            node->next_hop = NO_NEXT_HOP_PREFERENCE; // clear persisted route
+            clearRouteHealth(to);                    // clear RAM health
+            return std::nullopt;
+        }
+
        // We are careful not to return the relay node as the next hop
        if (node->next_hop != relay_node) {
-            // LOG_DEBUG("Next hop for 0x%x is 0x%x", to, node->next_hop);
-            return node->next_hop;
+            // M1/M2: only emit a stored next_hop if its last byte still maps to a UNIQUE, currently
+            // reachable direct neighbor. On a dense mesh the last byte collides, so an ambiguous byte
+            // would unicast a hint toward the wrong physical node; if the neighbor has gone away we'd
+            // unicast into a void. In both cases flood instead (managed flooding still delivers).
+            ResolvedNode r = nodeDB->resolveLastByte(node->next_hop, /*requireDirectNeighbor=*/true);
+            if (r.status == LastByteResolution::Unique)
+                return node->next_hop;
+            LOG_WARN("Next hop 0x%x for 0x%x %s; set no pref", node->next_hop, to,
+                     r.status == LastByteResolution::Ambiguous ? "ambiguous among neighbors" : "not a known neighbor");
        } else
            LOG_WARN("Next hop for 0x%x is 0x%x, same as relayer; set no pref", to, node->next_hop);
    }
+
+#if HAS_TRAFFIC_MANAGEMENT
+    // Fallback: TMM overflow cache holds confirmed hops for nodes that have aged out of the hot store.
+    // It is the same byte source/confidence as NodeInfoLite.next_hop, so it gets the same M1/M2/M3
+    // protection: decay a stale/failing route, then only emit a byte that still resolves to a unique
+    // reachable neighbor. Without this the overflow cache (which holds MORE bytes for MORE nodes) would
+    // reintroduce exactly the silent-misroute that M1/M2 closes on the hot path.
+    if (trafficManagementModule) {
+        uint8_t hint = trafficManagementModule->getNextHopHint(to);
+        if (hint && hint != relay_node) {
+            const RouteHealth *h = findRouteHealth(to);
+            if (h && h->lastNextHop == hint && isRouteStale(*h, millis())) {
+                LOG_INFO("TMM next hop 0x%x for 0x%x is stale (age/fails); flood and clear", hint, to);
+                trafficManagementModule->clearNextHop(to); // clear overflow route (setNextHop won't store 0)
+                clearRouteHealth(to);                      // clear RAM health
+                return std::nullopt;
+            }
+            ResolvedNode r = nodeDB->resolveLastByte(hint, /*requireDirectNeighbor=*/true);
+            if (r.status == LastByteResolution::Unique) {
+                LOG_DEBUG("Next hop for 0x%x is 0x%x (TMM cache)", to, hint);
+                return hint;
+            }
+            LOG_WARN("TMM next hop 0x%x for 0x%x %s; set no pref", hint, to,
+                     r.status == LastByteResolution::Ambiguous ? "ambiguous among neighbors" : "not a known neighbor");
+        }
+    }
+#endif
+
    return std::nullopt;
 }

@@ -311,7 +381,10 @@ int32_t NextHopRouter::doRetransmissions()

                if (!isBroadcast(p.packet->to)) {
                    if (p.numRetransmissions == 1) {
-                        // Last retransmission, reset next_hop (fallback to FloodingRouter)
+                        // Last retransmission: this directed delivery went un-ACKed. Record the failure
+                        // (M3 — accumulates across DMs to age out a flapping/dead route) and reset
+                        // next_hop so the final try falls back to FloodingRouter.
+                        noteRouteFailure(p.packet->to);
                        p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
                        // Also reset it in the nodeDB
                        meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
@@ -319,9 +392,32 @@ int32_t NextHopRouter::doRetransmissions()
                            LOG_INFO("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
                            sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
                        }
+#if HAS_TRAFFIC_MANAGEMENT
+                        if (trafficManagementModule) {
+                            trafficManagementModule->clearNextHop(p.packet->to);
+                        }
+#endif
                        FloodingRouter::send(packetPool.allocCopy(*p.packet));
                    } else {
+#if NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED
+                        // M4 (gated): if the route isn't proven healthy, don't spend a second directed
+                        // attempt — start flooding one retry sooner to cut recovery latency. A verified
+                        // route (fresh, zero recent failures) keeps the unchanged directed-retry path so
+                        // the sparse-mesh happy path is untouched.
+                        RouteHealth *h = findRouteHealth(p.packet->to);
+                        bool verified = h && h->consecutiveFailures == 0 && !isRouteStale(*h, now);
+                        if (!verified) {
+                            p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
+                            meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
+                            if (sentTo)
+                                sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
+                            FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                        } else {
+                            NextHopRouter::send(packetPool.allocCopy(*p.packet));
+                        }
+#else
                        NextHopRouter::send(packetPool.allocCopy(*p.packet));
+#endif
                    }
                } else {
                    // Note: we call the superclass version because we don't want to have our version of send() add a new
@@ -355,3 +451,96 @@ void NextHopRouter::setNextTx(PendingPacket *pending)
    printPacket("", pending->packet);
    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
 }
+
+// ---------------------------------------------------------------------------
+// M3: RAM route-health table. Bounded array with reuse-oldest eviction (same discipline as
+// PacketHistory). All age comparisons use unsigned subtraction so they survive the 49.7-day millis()
+// rollover. dest == 0 marks an empty slot; learnedAtMsec is normalized to 1 on write so an occupied
+// slot is never read as infinitely old.
+// ---------------------------------------------------------------------------
+
+RouteHealth *NextHopRouter::findRouteHealth(NodeNum dest)
+{
+    if (dest == 0)
+        return nullptr;
+    for (auto &h : routeHealth)
+        if (h.dest == dest)
+            return &h;
+    return nullptr;
+}
+
+RouteHealth *NextHopRouter::getOrAllocRouteHealth(NodeNum dest, uint32_t now)
+{
+    if (dest == 0)
+        return nullptr;
+
+    RouteHealth *oldest = &routeHealth[0];
+    RouteHealth *freeSlot = nullptr;
+    for (auto &h : routeHealth) {
+        if (h.dest == dest)
+            return &h; // existing record
+        if (h.dest == 0) {
+            if (!freeSlot)
+                freeSlot = &h; // remember the first free slot; prefer it over evicting
+            continue;
+        }
+        // Track the oldest occupied slot in case the table is full (rollover-safe).
+        if ((uint32_t)(now - h.learnedAtMsec) > (uint32_t)(now - oldest->learnedAtMsec))
+            oldest = &h;
+    }
+    // Claim the free slot if there is one, else reuse the oldest. Reset before use and stamp the dest
+    // so the record is findable.
+    RouteHealth *slot = freeSlot ? freeSlot : oldest;
+    *slot = RouteHealth{};
+    slot->dest = dest;
+    return slot;
+}
+
+void NextHopRouter::noteRouteLearned(NodeNum dest, uint8_t nextHop, uint32_t now)
+{
+    if (dest == 0 || nextHop == NO_NEXT_HOP_PREFERENCE)
+        return;
+    RouteHealth *h = getOrAllocRouteHealth(dest, now);
+    if (!h)
+        return;
+    // A genuinely new next hop earns a clean slate; re-learning the SAME hop keeps the accumulated
+    // failure count so an asymmetric reverse path that keeps re-teaching a dead forward hop still ages
+    // out instead of resetting the counter every time.
+    if (h->lastNextHop != nextHop) {
+        h->lastNextHop = nextHop;
+        h->consecutiveFailures = 0;
+    }
+    h->learnedAtMsec = now ? now : 1;
+}
+
+void NextHopRouter::noteRouteSuccess(NodeNum dest, uint32_t now)
+{
+    RouteHealth *h = findRouteHealth(dest);
+    if (!h)
+        return; // only routes we actually learned have health to refresh
+    h->consecutiveFailures = 0;
+    h->learnedAtMsec = now ? now : 1;
+}
+
+void NextHopRouter::noteRouteFailure(NodeNum dest)
+{
+    RouteHealth *h = findRouteHealth(dest);
+    if (!h)
+        return; // nothing to penalize (we were flooding, or never learned a route here)
+    if (h->consecutiveFailures < 255)
+        h->consecutiveFailures++;
+}
+
+bool NextHopRouter::isRouteStale(const RouteHealth &h, uint32_t now) const
+{
+    if (h.consecutiveFailures >= ROUTE_FAILURE_THRESHOLD)
+        return true;
+    return (uint32_t)(now - h.learnedAtMsec) >= ROUTE_TTL_MSEC;
+}
+
+void NextHopRouter::clearRouteHealth(NodeNum dest)
+{
+    RouteHealth *h = findRouteHealth(dest);
+    if (h)
+        *h = RouteHealth{};
+}
@@ -43,6 +43,28 @@ struct PendingPacket {
    explicit PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions);
 };

+/**
+ * RAM-only per-destination route health. Tracks how fresh a learned next_hop is and how many
+ * consecutive directed deliveries to it have failed, so getNextHop() can proactively decay a stale or
+ * repeatedly-failing route back to flooding instead of trusting a dead hop on the next (and on dense
+ * meshes, slowest) attempt. Not persisted: the learned next_hop itself lives in NodeInfoLite; this is
+ * just freshness/failure metadata.
+ */
+struct RouteHealth {
+    NodeNum dest = 0;                             ///< destination this record describes; 0 == empty slot
+    uint32_t learnedAtMsec = 0;                   ///< millis() when next_hop was last (re)learned (rollover-aware)
+    uint8_t consecutiveFailures = 0;              ///< directed deliveries to `dest` that went un-ACKed
+    uint8_t lastNextHop = NO_NEXT_HOP_PREFERENCE; ///< the relay byte this health refers to
+};
+
+// M4 (optional, off by default): when a route is not proven healthy, fall back to flooding one retry
+// earlier instead of spending a second directed attempt. Trades airtime for recovery latency on dense
+// meshes; leaves the sparse-mesh happy path (fresh, verified routes) unchanged. Measure on the
+// simulator before enabling broadly.
+#ifndef NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED
+#define NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED 0
+#endif
+
 class GlobalPacketIdHashFunction
 {
  public:
@@ -92,12 +114,22 @@ class NextHopRouter : public FloodingRouter
    // The number of retransmissions the original sender will do
    constexpr static uint8_t NUM_RELIABLE_RETX = 3;

+    // M3: bounded RAM route-health table (reuse-oldest eviction, like PacketHistory)
+    constexpr static uint8_t ROUTE_HEALTH_MAX = 32;              // ~12B/slot -> ~384B
+    constexpr static uint32_t ROUTE_TTL_MSEC = 30UL * 60 * 1000; // re-discover a route unconfirmed for 30 min
+    constexpr static uint8_t ROUTE_FAILURE_THRESHOLD = 3;        // consecutive un-ACKed directed deliveries -> dead
+
  protected:
    /**
     * Pending retransmissions
     */
    std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;

+    /**
+     * Per-destination route health (M3). Bounded array, reuse-oldest eviction. RAM-only.
+     */
+    RouteHealth routeHealth[ROUTE_HEALTH_MAX] = {};
+
    /**
     * Should this incoming filter be dropped?
     *
@@ -142,13 +174,38 @@ class NextHopRouter : public FloodingRouter

    void setNextTx(PendingPacket *pending);

+    // --- M3 route-health helpers (RAM-only). Protected so ReliableRouter (a subclass) can record
+    // delivery success, and so the unit-test shim can reach them via `using`. All take `now` where
+    // time matters so the decay logic is pure and testable without a clock mock. ---
+
+    /// @return the health record for `dest`, or nullptr if we hold none.
+    RouteHealth *findRouteHealth(NodeNum dest);
+    /// @return an existing record for `dest`, else a freshly claimed slot (reuse-oldest on overflow).
+    RouteHealth *getOrAllocRouteHealth(NodeNum dest, uint32_t now);
+    /// Record that we (re)learned `nextHop` for `dest`. Resets the failure count only when the hop
+    /// changed (so a flapping reverse-path re-learn of the same dead hop still ages out).
+    void noteRouteLearned(NodeNum dest, uint8_t nextHop, uint32_t now);
+    /// Record an end-to-end delivery success to `dest` (clears failures, refreshes freshness).
+    void noteRouteSuccess(NodeNum dest, uint32_t now);
+    /// Record that a directed delivery to `dest` went un-ACKed (no-op if we hold no record).
+    void noteRouteFailure(NodeNum dest);
+    /// @return true if the route is too old (TTL) or has failed too many times in a row.
+    bool isRouteStale(const RouteHealth &h, uint32_t now) const;
+    /// Forget any health record for `dest`.
+    void clearRouteHealth(NodeNum dest);
+
+#ifdef PIO_UNIT_TESTING
+  public: // expose getNextHop to the test shim without widening production visibility
+#else
  private:
+#endif
    /**
     * Get the next hop for a destination, given the relay node
     * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
     */
    std::optional<uint8_t> getNextHop(NodeNum to, uint8_t relay_node);

+  private:
    /** Check if we should be rebroadcasting this packet if so, do so.
     *  @return true if we did rebroadcast */
    bool perhapsRebroadcast(const meshtastic_MeshPacket *p) override;
@@ -66,6 +66,10 @@
 #include <utility/bonding.h>
 #endif

+#ifdef ARCH_RP2040
+#include <hardware/watchdog.h>
+#endif
+
 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
 #include <MeshtasticOTA.h>
 #endif
@@ -590,6 +594,16 @@ NodeDB::NodeDB()
        moduleConfig.mqtt.map_report_settings.publish_interval_secs = default_map_publish_interval_secs;
    }

+    // If a fixed position is configured, restore the persisted position into localPosition at boot.
+    // This keeps position broadcasts / MQTT map reports working after reboot on GPS-less nodes.
+    if (config.position.fixed_position) {
+        meshtastic_PositionLite fixedPos;
+        if (copyNodePosition(getNodeNum(), fixedPos) && (fixedPos.latitude_i != 0 || fixedPos.longitude_i != 0)) {
+            setLocalPosition(TypeConversions::ConvertToPosition(fixedPos));
+            LOG_INFO("Restored fixed position to localPosition: lat=%d lon=%d", fixedPos.latitude_i, fixedPos.longitude_i);
+        }
+    }
+
    // Ensure that the neighbor info update interval is coerced to the minimum
    moduleConfig.neighbor_info.update_interval =
        Default::getConfiguredOrMinimumValue(moduleConfig.neighbor_info.update_interval, min_neighbor_info_broadcast_secs);
@@ -1145,6 +1159,24 @@ void NodeDB::initConfigIntervals()
 #endif
 }

+// Always-on traffic management defaults. Only booleans are written; every
+// numeric field stays 0 and resolves to its default_traffic_mgmt_* macro at
+// use (e.g. position dedup precision/interval), so fork-wide tuning changes
+// take effect without another migration. Rate limiting and the features that
+// exhaust or reshape relayed traffic (exhaust_hop_*, drop_unknown_enabled,
+// nodeinfo_direct_response) stay opt-in.
+static void installTrafficManagementDefaults(meshtastic_LocalModuleConfig &mc)
+{
+    mc.has_traffic_management = true;
+    mc.traffic_management = meshtastic_ModuleConfig_TrafficManagementConfig_init_zero;
+#if HAS_TRAFFIC_MANAGEMENT
+    // Position dedup ships enabled at the 11-hour default window on all supported targets.
+    // STM32WL is excluded at compile time (HAS_TRAFFIC_MANAGEMENT=0 in mesh-pb-constants.h).
+    // Set position_min_interval_secs=0 at runtime to disable dedup.
+    mc.traffic_management.position_min_interval_secs = default_traffic_mgmt_position_min_interval_secs;
+#endif
+}
+
 void NodeDB::installDefaultModuleConfig()
 {
    LOG_INFO("Install default ModuleConfig");
@@ -1262,6 +1294,8 @@ void NodeDB::installDefaultModuleConfig()
    moduleConfig.has_neighbor_info = true;
    moduleConfig.neighbor_info.enabled = false;

+    installTrafficManagementDefaults(moduleConfig);
+
    moduleConfig.has_detection_sensor = true;
    moduleConfig.detection_sensor.enabled = false;
    moduleConfig.detection_sensor.detection_trigger_type = meshtastic_ModuleConfig_DetectionSensorConfig_TriggerType_LOGIC_HIGH;
@@ -1613,6 +1647,27 @@ bool NodeDB::enforceSatelliteCaps()
    return trimmedAny;
 }

+#if WARM_NODE_COUNT > 0
+// Classify an evicted node's hop-protected category for the warm tier. Favorite/ignored/
+// verified are local flags (rarely reach warm — they're eviction-protected — but classify
+// them if they do); otherwise tracker/sensor/tak_tracker are role-protected.
+static uint8_t warmProtectedCategory(const meshtastic_NodeInfoLite &n)
+{
+    if (n.bitfield & (NODEINFO_BITFIELD_IS_FAVORITE_MASK | NODEINFO_BITFIELD_IS_IGNORED_MASK |
+                      NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK))
+        return static_cast<uint8_t>(WarmProtected::Flag);
+    if (IS_ONE_OF(n.role, meshtastic_Config_DeviceConfig_Role_TRACKER, meshtastic_Config_DeviceConfig_Role_SENSOR,
+                  meshtastic_Config_DeviceConfig_Role_TAK_TRACKER))
+        return static_cast<uint8_t>(WarmProtected::Role);
+    return static_cast<uint8_t>(WarmProtected::None);
+}
+
+// The warm tier packs the device role into a 4-bit field (WARM_ROLE_MASK). Fail the build
+// loudly if a new role outgrows it, rather than silently truncating role on eviction.
+static_assert(_meshtastic_Config_DeviceConfig_Role_MAX <= WARM_ROLE_MASK,
+              "device role no longer fits the 4-bit warm metadata field");
+#endif // WARM_NODE_COUNT > 0
+
 void NodeDB::cleanupMeshDB()
 {
    int newPos = 0, removed = 0;
@@ -1639,7 +1694,7 @@ void NodeDB::cleanupMeshDB()
                // Keep any key we learned (e.g. via a DM before the NodeInfo
                // exchange completed) rather than losing it with the purge.
                if (n.public_key.size == 32)
-                    warmStore.absorb(gone, n.last_heard, n.public_key.bytes);
+                    warmStore.absorb(gone, n.last_heard, n.public_key.bytes, n.role, warmProtectedCategory(n));
 #endif

                eraseNodeSatellites(gone);
@@ -1822,7 +1877,8 @@ void NodeDB::demoteOldestHotNodesToWarm()
            continue;
        // Keep the public key if we have one (40 B warm record); keyless nodes
        // still get a placeholder so re-admission restores last_heard.
-        warmStore.absorb(n.num, n.last_heard, n.public_key.size > 0 ? n.public_key.bytes : nullptr);
+        warmStore.absorb(n.num, n.last_heard, n.public_key.size > 0 ? n.public_key.bytes : nullptr, n.role,
+                         warmProtectedCategory(n));
        // Demotion drops the node from the header table, so drop its satellites
        // too (the eviction chokepoint) — they'd otherwise orphan until the next
        // enforceSatelliteCaps pass.
@@ -2226,6 +2282,16 @@ void NodeDB::loadFromDisk()
        }
    }

+    // Always-on traffic management: a device that has NEVER configured TMM
+    // (has_traffic_management false — AdminModule always sets the has_ flag on
+    // write, even when disabling) gets the fork defaults. Explicitly configured
+    // devices keep their exact settings.
+    if (!moduleConfig.has_traffic_management) {
+        LOG_INFO("Traffic management never configured, installing always-on defaults");
+        installTrafficManagementDefaults(moduleConfig);
+        saveToDisk(SEGMENT_MODULECONFIG);
+    }
+
    state = loadProto(channelFileName, meshtastic_ChannelFile_size, sizeof(meshtastic_ChannelFile), &meshtastic_ChannelFile_msg,
                      &channelFile);
    if (state != LoadFileResult::LOAD_SUCCESS) {
@@ -2620,6 +2686,11 @@ bool NodeDB::saveNodeDatabaseToDisk()
    nodeDatabase.status.clear();
    nodeDatabase.status.shrink_to_fit();
 #if WARM_NODE_COUNT > 0
+#ifdef ARCH_RP2040
+    // nodes.proto + warm.dat are written back-to-back without the loop running between them;
+    // reset the 8s HW watchdog so the second write gets a full budget (issue #10746).
+    watchdog_update();
+#endif
    // Same cadence as the node DB; failure is logged but must not propagate —
    // a false return from here would trigger saveToDisk()'s fsFormat() path.
    warmStore.saveIfDirty();
@@ -2773,6 +2844,10 @@ HopStartStatus classifyHopStart(const meshtastic_MeshPacket &p)
        return HopStartStatus::INVALID;

    if (p.hop_start == 0) {
+        // hop_start == hop_limit == 0: intentional zero-hop broadcast (e.g. beacon). Valid by definition —
+        // the packet was never meant to travel any hops, so no hop_start ambiguity applies.
+        if (p.hop_limit == 0)
+            return HopStartStatus::VALID;
        // Firmware prior to 2.3.0 (585805c) lacked a hop_start field. Firmware version 2.5.0 (bf34329) introduced a
        // bitfield that is always present. Use the presence of the bitfield to determine if the origin's firmware
        // version is guaranteed to have hop_start populated. Note that this can only be done for decoded packets as
@@ -3113,8 +3188,14 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
                           mp.via_mqtt); // Store if we received this packet via MQTT

 #if HAS_VARIABLE_HOPS
-        // Only sample packets that arrived over LoRa.
-        if (mp.transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && hopScalingModule) {
+        // Only sample genuine RF-origin packets. The transport check excludes packets received
+        // directly from the broker (TRANSPORT_MQTT), but an MQTT-origin packet rebroadcast onto
+        // LoRa by a gateway arrives as TRANSPORT_LORA with via_mqtt set — count those would
+        // inflate the local mesh-size estimate with non-RF nodes (and they usually carry
+        // hop_start==0, landing in the hop-0 bucket that pulls the recommendation lowest), so
+        // exclude via_mqtt too.
+        if (mp.transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA && !mp.via_mqtt &&
+            hopScalingModule) {
            uint8_t hopCount = std::max(int8_t(0), getHopsAway(mp));
            hopScalingModule->samplePacketForHistogram(mp.from, hopCount);
        }
@@ -3295,6 +3376,73 @@ meshtastic_NodeInfoLite *NodeDB::getMeshNode(NodeNum n)
    return NULL;
 }

+ResolvedNode NodeDB::resolveLastByte(uint8_t lastByte, bool requireDirectNeighbor)
+{
+    ResolvedNode result; // defaults to {None, 0}
+
+    // 0 is the NO_RELAY_NODE / NO_NEXT_HOP_PREFERENCE sentinel (also what MQTT-sourced packets carry
+    // when hop_start==0). getLastByteOfNodeNum() never yields 0, so nothing can legitimately match.
+    if (lastByte == 0)
+        return result;
+
+    const NodeNum self = getNodeNum();
+    NodeNum firstMatch = 0;
+    uint8_t matches = 0;
+
+    for (size_t i = 0; i < numMeshNodes; i++) {
+        const meshtastic_NodeInfoLite *node = &meshNodes->at(i);
+
+        // Candidate gate: never resolve to ourselves, the sentinels, or an ignored node.
+        if (node->num == self || node->num == 0 || node->num == NODENUM_BROADCAST)
+            continue;
+        if (nodeInfoLiteIsIgnored(node))
+            continue;
+        if (getLastByteOfNodeNum(node->num) != lastByte) // cheapest discriminator last
+            continue;
+
+        // Relevance gate: is this node a plausible relay for the requested scope?
+        bool relevant;
+        if (requireDirectNeighbor) {
+            relevant = node->has_hops_away && node->hops_away == 0 && sinceLastSeen(node) < NEXTHOP_NEIGHBOR_FRESH_SECS;
+        } else {
+            const bool directNeighbor = node->has_hops_away && node->hops_away == 0;
+            const bool routerRole =
+                IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE,
+                          meshtastic_Config_DeviceConfig_Role_CLIENT_BASE);
+            relevant = directNeighbor || nodeInfoLiteIsFavorite(node) || routerRole;
+        }
+        if (!relevant)
+            continue;
+
+        if (++matches == 1) {
+            firstMatch = node->num;
+        } else {
+            // A second relevant candidate shares this byte: ambiguous. No further scanning can
+            // change that, so stop early and report the collision.
+            result.status = LastByteResolution::Ambiguous;
+            result.num = 0;
+            return result;
+        }
+    }
+
+    if (matches == 1) {
+        result.status = LastByteResolution::Unique;
+        result.num = firstMatch;
+    }
+    return result;
+}
+
+bool NodeDB::resolveUniqueLastByte(uint8_t lastByte, bool requireDirectNeighbor, NodeNum *outNum)
+{
+    ResolvedNode r = resolveLastByte(lastByte, requireDirectNeighbor);
+    if (r.status == LastByteResolution::Unique) {
+        if (outNum)
+            *outNum = r.num;
+        return true;
+    }
+    return false;
+}
+
 // returns true if the maximum number of nodes is reached or we are running low on memory
 bool NodeDB::isFull()
 {
@@ -3325,6 +3473,20 @@ bool NodeDB::copyPublicKey(NodeNum n, meshtastic_NodeInfoLite_public_key_t &out)
    return false;
 }

+meshtastic_Config_DeviceConfig_Role NodeDB::getNodeRole(NodeNum n)
+{
+    const meshtastic_NodeInfoLite *info = getMeshNode(n);
+    if (nodeInfoLiteHasUser(info))
+        return info->role;
+#if WARM_NODE_COUNT > 0
+    // Hot-store miss: fall back to the role the warm tier cached at eviction.
+    uint8_t role = 0, prot = 0;
+    if (warmStore.lookupMeta(n, role, prot))
+        return static_cast<meshtastic_Config_DeviceConfig_Role>(role);
+#endif
+    return meshtastic_Config_DeviceConfig_Role_CLIENT;
+}
+
 /// Find a node in our DB, create an empty NodeInfo if missing
 meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 {
@@ -3365,8 +3527,8 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
 #if WARM_NODE_COUNT > 0
                // Demote to the warm tier so the identity (and crucially the
                // PKI key) outlives the hot-store slot.
-                warmStore.absorb(evicted.num, evicted.last_heard,
-                                 evicted.public_key.size == 32 ? evicted.public_key.bytes : NULL);
+                warmStore.absorb(evicted.num, evicted.last_heard, evicted.public_key.size == 32 ? evicted.public_key.bytes : NULL,
+                                 evicted.role, warmProtectedCategory(evicted));
 #endif
                eraseNodeSatellites(evicted.num);
                // Shove the remaining nodes down the chain
@@ -3395,7 +3557,10 @@ meshtastic_NodeInfoLite *NodeDB::getOrCreateMeshNode(NodeNum n)
        // Re-admission: restore what the warm tier kept for this node
        WarmNodeEntry warm;
        if (warmStore.take(n, warm)) {
-            lite->last_heard = warm.last_heard;
+            lite->last_heard = warmTimeOf(warm); // mask off the stolen role/protected metadata bits
+            // Restore the role the warm tier cached, so re-admission isn't stuck at CLIENT
+            // until the next NodeInfo arrives.
+            lite->role = static_cast<meshtastic_Config_DeviceConfig_Role>(warmRoleOf(warm));
            if (!memfll(warm.public_key, 0, sizeof(warm.public_key))) {
                lite->public_key.size = 32;
                memcpy(lite->public_key.bytes, warm.public_key, 32);
@@ -3544,6 +3709,8 @@ bool NodeDB::createNewIdentity()
    myNodeInfo.my_node_num = newNodeNum;

    meshtastic_NodeInfoLite *info = getOrCreateMeshNode(getNodeNum());
+    if (!info)
+        return false;
    TypeConversions::CopyUserToNodeInfoLite(info, owner);

    return true;
@@ -115,6 +115,20 @@ uint32_t sinceLastSeen(const meshtastic_NodeInfoLite *n);
 /// Given a packet, return how many seconds in the past (vs now) it was received
 uint32_t sinceReceived(const meshtastic_MeshPacket *p);

+/// Outcome of mapping a single on-wire last-byte (next_hop / relay_node) back to a full NodeNum.
+/// Because the wire only carries the last byte of a 32-bit node number, the mapping is ambiguous on
+/// dense meshes (the "birthday problem"). Callers must treat Ambiguous and None as "don't trust it".
+enum class LastByteResolution : uint8_t {
+    None,      ///< no relevant candidate node has this last byte
+    Unique,    ///< exactly one relevant candidate -> `num` is valid
+    Ambiguous, ///< two or more relevant candidates collide on this byte
+};
+
+struct ResolvedNode {
+    LastByteResolution status = LastByteResolution::None;
+    NodeNum num = 0; ///< valid only when status == Unique
+};
+
 /// Given a packet, return the number of hops used to reach this node.
 /// Returns defaultIfUnknown if the number of hops couldn't be determined.
 int8_t getHopsAway(const meshtastic_MeshPacket &p, int8_t defaultIfUnknown = -1);
@@ -327,10 +341,32 @@ class NodeDB
    /// tier. Returns false if we don't know a key for n.
    bool copyPublicKey(NodeNum n, meshtastic_NodeInfoLite_public_key_t &out);

+    /// Resolve a node's device role — hot store (with user) first, then the role
+    /// cached in the warm tier, else CLIENT. Lets role-aware policy keep firing for
+    /// nodes that have aged out of the hot store.
+    meshtastic_Config_DeviceConfig_Role getNodeRole(NodeNum n);
+
    /// last_heard of a hot-store node, or 0 if absent. Plain scan of meshNodes
    /// with no allocation side effects (unlike getOrCreateMeshNode).
    uint32_t hotNodeLastHeard(NodeNum n) const;

+    /**
+     * Resolve a single on-wire last-byte (e.g. next_hop / relay_node) back to a unique full NodeNum,
+     * detecting last-byte collisions instead of silently picking the first match. A 1-byte id only
+     * needs to be unique among a node's plausible relays, not the whole mesh, so we scope the search:
+     *  - requireDirectNeighbor == true  : candidates are direct neighbors (hops_away==0) heard within
+     *                                     NEXTHOP_NEIGHBOR_FRESH_SECS. Use on the SEND path.
+     *  - requireDirectNeighbor == false : also accept favorites and router-role nodes (unknown hop
+     *                                     distance allowed). Use when learning / preserving hops.
+     * Ignored nodes, our own node, and the broadcast/0 sentinels are never candidates. On a tie the
+     * result is Ambiguous (no tie-break) so callers fall back to flooding rather than misroute.
+     */
+    ResolvedNode resolveLastByte(uint8_t lastByte, bool requireDirectNeighbor);
+
+    /// Convenience wrapper around resolveLastByte(): true iff exactly one relevant candidate matches.
+    /// Ambiguous and None both return false (the safe answer for learning / hop preservation).
+    bool resolveUniqueLastByte(uint8_t lastByte, bool requireDirectNeighbor, NodeNum *outNum = nullptr);
+
    // Thread-safe satellite-map accessors. Return false if absent or the
    // corresponding DB is compiled out.
    bool copyNodePosition(NodeNum n, meshtastic_PositionLite &out) const;
@@ -486,7 +486,11 @@ bool PacketHistory::wasRelayer(const uint8_t relayer, const uint32_t id, const N
 }

 /* Check if a certain node was a relayer of a packet in the history given iterator
- * @return true if node was indeed a relayer, false if not */
+ * @return true if node was indeed a relayer, false if not
+ * NOTE: intentionally byte-domain. Both `relayer` and relayed_by[] are on-wire last bytes, so this
+ * answers "did a relayer with this byte touch the packet" — correct without resolving to a NodeNum.
+ * The collision risk is neutralized where the result is consumed (route learning in
+ * NextHopRouter::sniffReceived now gates the write through NodeDB::resolveUniqueLastByte). */
 bool PacketHistory::wasRelayer(const uint8_t relayer, const PacketRecord &r, bool *wasSole)
 {
    bool found = false;
@@ -12,6 +12,7 @@
 #include "Channels.h"
 #include "Default.h"
 #include "FSCommon.h"
+#include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PacketHistory.h"
@@ -516,9 +517,10 @@ bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
    STATE_SEND_UIDATA,
    STATE_SEND_OWN_NODEINFO,
    STATE_SEND_METADATA,
-    STATE_SEND_CHANNELS
+    STATE_SEND_REGION_PRESETS, // region -> valid modem presets (one message)
+    STATE_SEND_CHANNELS,
    STATE_SEND_CONFIG,
-    STATE_SEND_MODULE_CONFIG,
+    STATE_SEND_MODULECONFIG,
    STATE_SEND_OTHER_NODEINFOS, // states progress in this order as the device sends to the client
    STATE_SEND_FILEMANIFEST,
    STATE_SEND_COMPLETE_ID,
@@ -636,7 +638,20 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
            memset(&fromRadioScratch.metadata, 0, sizeof(fromRadioScratch.metadata));
        }
 #endif
+        state = STATE_SEND_REGION_PRESETS;
+        break;
+
+    case STATE_SEND_REGION_PRESETS:
+        // Tell the client which modem presets are legal in each region so its UI
+        // can block illegal region+preset combinations. This is public RF /
+        // regulatory information (region and modem_preset are already in the
+        // unauthenticated LoRa whitelist below), so it is sent unconditionally —
+        // even an unauthorized/locked-down client can render a correct picker.
+        LOG_DEBUG("Send region preset map");
+        fromRadioScratch.which_payload_variant = meshtastic_FromRadio_region_presets_tag;
+        getRegionPresetMap(fromRadioScratch.region_presets);
        state = STATE_SEND_CHANNELS;
+        config_state = 0; // STATE_SEND_CHANNELS indexes channels starting at 0
        break;

    case STATE_SEND_CHANNELS:
@@ -1517,6 +1532,7 @@ bool PhoneAPI::available()
    case STATE_SEND_CONFIG:
    case STATE_SEND_MODULECONFIG:
    case STATE_SEND_METADATA:
+    case STATE_SEND_REGION_PRESETS:
    case STATE_SEND_OWN_NODEINFO:
    case STATE_SEND_FILEMANIFEST:
    case STATE_SEND_COMPLETE_ID:
@@ -46,6 +46,7 @@ class PhoneAPI
        STATE_SEND_MY_INFO, // send our my info record
        STATE_SEND_OWN_NODEINFO,
        STATE_SEND_METADATA,
+        STATE_SEND_REGION_PRESETS,  // Send the region->valid-preset map (one message)
        STATE_SEND_CHANNELS,        // Send all channels
        STATE_SEND_CONFIG,          // Replacement for the old Radioconfig
        STATE_SEND_MODULECONFIG,    // Send Module specific config
@@ -28,8 +28,11 @@ uint32_t getPositionPrecisionForChannel(uint8_t channelIndex)
    return precision;
 }

-static int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)
+int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)
 {
+    if (precision == 0 || precision >= 32)
+        return coordinate;
+
    uint32_t coordinateBits = static_cast<uint32_t>(coordinate);
    uint32_t truncated = coordinateBits & (UINT32_MAX << (32 - precision));

@@ -39,6 +42,11 @@ static int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)
    return static_cast<int32_t>(truncated);
 }

+int32_t truncateCoordinate(int32_t coordinate, uint8_t precision)
+{
+    return truncateCoordinate(coordinate, static_cast<uint32_t>(precision));
+}
+
 void applyPositionPrecision(meshtastic_Position &position, uint32_t precision)
 {
    if (precision == 0) {
@@ -15,6 +15,12 @@ uint32_t getPositionPrecisionForChannel(const meshtastic_Channel &channel);

 // Configured precision, clamped to MAX_POSITION_PRECISION_PUBLIC_KEY when the channel's effective key is publicly decryptable.
 uint32_t getPositionPrecisionForChannel(uint8_t channelIndex);
+
+// Truncate a single latitude_i/longitude_i to `precision` significant bits, centered in the
+// resulting grid cell (stable under GPS jitter). precision 0 or >=32 returns the value unchanged.
+// The return is the coordinate (int32_t); the uint8_t overload only narrows the precision arg.
+int32_t truncateCoordinate(int32_t coordinate, uint32_t precision);
+int32_t truncateCoordinate(int32_t coordinate, uint8_t precision);
 void applyPositionPrecision(meshtastic_Position &position, uint32_t precision);
 bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision);
 bool applyPositionPrecisionForChannel(meshtastic_MeshPacket &packet, uint8_t channelIndex);
@@ -26,6 +26,7 @@

 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
+#include "platform/portduino/SerialHal.h"
 #include "platform/portduino/SimRadio.h"
 #include "platform/portduino/USBHal.h"
 #endif
@@ -352,6 +353,9 @@ std::unique_ptr<RadioInterface> initLoRa()
              portduino_config.lora_spi_dev.c_str());
    if (portduino_config.lora_spi_dev == "ch341") {
        RadioLibHAL = ch341Hal;
+    } else if (portduino_config.lora_spi_dev == "serial") {
+        RadioLibHAL = new SerialHal(portduino_config.lora_serial_device, portduino_config.lora_serial_baud,
+                                    (uint32_t)portduino_config.lora_serial_timeout_ms);
    } else {
        if (RadioLibHAL != nullptr) {
            delete RadioLibHAL;
@@ -605,6 +609,62 @@ const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code)
    return r;
 }

+void getRegionPresetMap(meshtastic_LoRaRegionPresetMap &map)
+{
+    map = meshtastic_LoRaRegionPresetMap_init_zero;
+
+    const size_t maxGroups = sizeof(map.groups) / sizeof(map.groups[0]);
+    const size_t maxRegions = sizeof(map.region_groups) / sizeof(map.region_groups[0]);
+    const size_t maxPresets = sizeof(map.groups[0].presets) / sizeof(map.groups[0].presets[0]);
+
+    // Coalesce regions that share an identical preset list into one group. Two
+    // regions belong to the same group when they share the same RegionProfile
+    // (which owns the preset list + licensing) AND the same default preset.
+    // Keyed by profile pointer, not the preset-array pointer: PROFILE_NARROW and
+    // PROFILE_HAM_100KHZ share PRESETS_NARROW but differ in licensedOnly.
+    const RegionProfile *groupProfile[sizeof(map.groups) / sizeof(map.groups[0])] = {};
+
+    for (const RegionInfo *r = regions; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET; r++) {
+        // No room left to map any further region; once full we can't add more, so
+        // log once and stop. An incomplete map means clients won't constrain the
+        // omitted regions, so this must be discoverable rather than silent.
+        if (map.region_groups_count >= maxRegions) {
+            LOG_ERROR("Region preset map full at %u regions; remaining regions omitted", (unsigned)maxRegions);
+            break;
+        }
+
+        // Find the group this region belongs to, or create it.
+        int gi = -1;
+        for (pb_size_t g = 0; g < map.groups_count; g++) {
+            if (groupProfile[g] == r->profile && map.groups[g].default_preset == r->getDefaultPreset()) {
+                gi = g;
+                break;
+            }
+        }
+        if (gi < 0) {
+            if (map.groups_count >= maxGroups) {
+                // Out of group slots (should not happen for the current table). The
+                // region can't be advertised; skip it but make the gap visible.
+                LOG_ERROR("Region preset map out of group slots (%u); region %d omitted", (unsigned)maxGroups, r->code);
+                continue;
+            }
+            gi = map.groups_count++;
+            groupProfile[gi] = r->profile;
+            meshtastic_LoRaPresetGroup &grp = map.groups[gi];
+            grp.default_preset = r->getDefaultPreset();
+            grp.licensed_only = r->profile->licensedOnly;
+            grp.presets_count = 0;
+            for (size_t i = 0; r->profile->presets[i] != MODEM_PRESET_END && grp.presets_count < maxPresets; i++)
+                grp.presets[grp.presets_count++] = r->profile->presets[i];
+        }
+
+        // Map this region to its group (capacity checked at the top of the loop).
+        meshtastic_LoRaRegionPresets &rg = map.region_groups[map.region_groups_count++];
+        rg.region = r->code;
+        rg.group_index = (uint8_t)gi;
+    }
+}
+
 /**
 * Get duty cycle for current region. EU_866: 10% for routers, 2.5% for mobile.
 */
@@ -151,6 +151,10 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
            LOG_DEBUG("Received a %s for 0x%x, stopping retransmissions", ackId ? "ACK" : "NAK", ackId);
            if (ackId) {
                stopRetransmission(p->to, ackId);
+                // M3: an end-to-end ACK proves the directed route to the ACK's sender currently works,
+                // so clear its failure count and refresh freshness (keeps a good route pinned).
+                if (!isBroadcast(getFrom(p)))
+                    noteRouteSuccess(getFrom(p), millis());
            } else {
                stopRetransmission(p->to, nakId);
            }
@@ -100,51 +100,31 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
        return true;
    }

-#if HAS_TRAFFIC_MANAGEMENT
-    // When router_preserve_hops is enabled, preserve hops for decoded packets that are not
-    // position or telemetry (those have their own exhaust_hop controls).
-    if (moduleConfig.has_traffic_management && moduleConfig.traffic_management.enabled &&
-        moduleConfig.traffic_management.router_preserve_hops && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-        p->decoded.portnum != meshtastic_PortNum_POSITION_APP && p->decoded.portnum != meshtastic_PortNum_TELEMETRY_APP) {
-        LOG_DEBUG("Router hop preserved: port=%d from=0x%08x (traffic_management)", p->decoded.portnum, getFrom(p));
-        if (trafficManagementModule) {
-            trafficManagementModule->recordRouterHopPreserved();
-        }
-        return false;
-    }
-#endif
+    // router_preserve_hops: not suitable right now — removed from config until
+    // the right heuristics for when to preserve vs. exhaust hops are established.
+    // #if HAS_TRAFFIC_MANAGEMENT
+    //     if (moduleConfig.has_traffic_management &&
+    //         moduleConfig.traffic_management.router_preserve_hops && ...) { ... }
+    // #endif

-    // For subsequent hops, check if previous relay is a favorite router
-    // Optimized search for favorite routers with matching last byte
-    // Check ordering optimized for IoT devices (cheapest checks first)
-    for (size_t i = 0; i < nodeDB->getNumMeshNodes(); i++) {
-        meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);
-        if (!node)
-            continue;
-
-        // Check 1: is_favorite (cheapest - single bit test)
-        if (!nodeInfoLiteIsFavorite(node))
-            continue;
-
-        // Check 2: has_user (cheap - single bit test)
-        if (!nodeInfoLiteHasUser(node))
-            continue;
-
-        // Check 3: role check (moderate cost - multiple comparisons)
-        if (!IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE,
-                       meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
-            continue;
-        }
-
-        // Check 4: last byte extraction and comparison (most expensive)
-        if (nodeDB->getLastByteOfNodeNum(node->num) == p->relay_node) {
-            // Found a favorite router match
-            LOG_DEBUG("Identified favorite relay router 0x%x from last byte 0x%x", node->num, p->relay_node);
+    // For subsequent hops, preserve hop_limit only when the previous relay is UNAMBIGUOUSLY a favorite
+    // router. The relay_node byte is just the last byte of a 32-bit node number, so on a dense mesh it
+    // collides; the old "first matching node wins" scan could preserve hops for the wrong node
+    // (non-deterministic, depends on NodeDB order). resolveLastByte() reports a collision instead, and
+    // we re-check the favorite/router predicate on the single resolved node. On ambiguity/none we
+    // decrement (the safe default).
+    NodeNum resolved = 0;
+    if (nodeDB->resolveUniqueLastByte(p->relay_node, /*requireDirectNeighbor=*/false, &resolved)) {
+        const meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(resolved);
+        if (node && nodeInfoLiteIsFavorite(node) && nodeInfoLiteHasUser(node) &&
+            IS_ONE_OF(node->role, meshtastic_Config_DeviceConfig_Role_ROUTER, meshtastic_Config_DeviceConfig_Role_ROUTER_LATE,
+                      meshtastic_Config_DeviceConfig_Role_CLIENT_BASE)) {
+            LOG_DEBUG("Identified unique favorite relay router 0x%x from last byte 0x%x", resolved, p->relay_node);
            return false; // Don't decrement hop_limit
        }
    }

-    // No favorite router match found, decrement hop_limit
+    // No unambiguous favorite router match found, decrement hop_limit
    return true;
 }

@@ -0,0 +1,385 @@
+#include "mesh/SerialHalDevice.h"
+#include "NodeDB.h"
+#include "SPILock.h"
+#include "concurrency/Periodic.h"
+#include "configuration.h"
+#include "mesh/StreamAPI.h"
+#include "mesh/generated/meshtastic/config.pb.h"
+#include <Arduino.h>
+#include <SPI.h>
+#include <cstring>
+#include <stdint.h>
+
+#if defined(ARCH_ESP32)
+#if defined(HW_SPI1_DEVICE)
+extern SPIClass SPI1;
+#endif
+#endif
+
+namespace
+{
+constexpr uint32_t SERIAL_PI_RISING = 1;
+constexpr uint32_t SERIAL_PI_FALLING = 2;
+constexpr uint32_t SERIAL_PI_INPUT = 0;
+constexpr uint32_t SERIAL_PI_OUTPUT = 1;
+constexpr size_t MAX_INTERRUPT_SLOTS = 8;
+constexpr int32_t INTERRUPT_POLL_MS = 5;
+
+struct InterruptSlot {
+    bool used = false;
+    uint32_t pin = 0;
+    uint32_t mode = 0;
+    volatile bool pending = false;
+};
+
+concurrency::Lock interruptMutex;
+InterruptSlot interruptSlots[MAX_INTERRUPT_SLOTS];
+StreamAPI *interruptStreamApi = nullptr;
+concurrency::Periodic *interruptEmitter = nullptr;
+
+int findSlotByPinLocked(uint32_t pin)
+{
+    for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+        if (interruptSlots[i].used && interruptSlots[i].pin == pin) {
+            return (int)i;
+        }
+    }
+    return -1;
+}
+
+int allocateSlotLocked()
+{
+    for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+        if (!interruptSlots[i].used) {
+            return (int)i;
+        }
+    }
+    return -1;
+}
+
+#if defined(ARCH_PORTDUINO) || defined(ARCH_RP2040)
+PinStatus toInterruptMode(uint32_t serialMode)
+{
+    if (serialMode == SERIAL_PI_RISING) {
+        return PinStatus::RISING;
+    }
+    if (serialMode == SERIAL_PI_FALLING) {
+        return PinStatus::FALLING;
+    }
+    return PinStatus::CHANGE;
+}
+#else
+int toInterruptMode(uint32_t serialMode)
+{
+    if (serialMode == SERIAL_PI_RISING) {
+        return RISING;
+    }
+    if (serialMode == SERIAL_PI_FALLING) {
+        return FALLING;
+    }
+    return CHANGE;
+}
+#endif
+
+int32_t pumpInterruptEvents();
+
+void ensureInterruptEmitter()
+{
+    if (!interruptEmitter) {
+        interruptEmitter = new concurrency::Periodic("SerialHalIrqEmitter", pumpInterruptEvents);
+    }
+}
+
+void emitInterruptEvent(uint32_t pin, StreamAPI *streamApi)
+{
+    if (streamApi == nullptr) {
+        return;
+    }
+
+    meshtastic_SerialHalResponse event = meshtastic_SerialHalResponse_init_zero;
+    event.transaction_id = 0; // asynchronous interrupt notification
+    event.result = meshtastic_SerialHalResponse_Result_OK;
+    event.value = pin; // host-side SerialHal treats value as interrupt pin
+    SerialHalDevice::emitResponse(event, streamApi);
+}
+
+void markPendingBySlot(uint8_t slot)
+{
+    if (slot < MAX_INTERRUPT_SLOTS && interruptSlots[slot].used) {
+        interruptSlots[slot].pending = true;
+    }
+}
+
+void isr0()
+{
+    markPendingBySlot(0);
+}
+void isr1()
+{
+    markPendingBySlot(1);
+}
+void isr2()
+{
+    markPendingBySlot(2);
+}
+void isr3()
+{
+    markPendingBySlot(3);
+}
+void isr4()
+{
+    markPendingBySlot(4);
+}
+void isr5()
+{
+    markPendingBySlot(5);
+}
+void isr6()
+{
+    markPendingBySlot(6);
+}
+void isr7()
+{
+    markPendingBySlot(7);
+}
+
+void (*const isrTable[MAX_INTERRUPT_SLOTS])() = {isr0, isr1, isr2, isr3, isr4, isr5, isr6, isr7};
+
+int32_t pumpInterruptEvents()
+{
+    uint32_t toEmit[MAX_INTERRUPT_SLOTS] = {0};
+    size_t emitCount = 0;
+    StreamAPI *streamApi = nullptr;
+
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        streamApi = interruptStreamApi;
+        for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+            if (interruptSlots[i].used && interruptSlots[i].pending) {
+                interruptSlots[i].pending = false;
+                toEmit[emitCount++] = interruptSlots[i].pin;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < emitCount; ++i) {
+        emitInterruptEvent(toEmit[i], streamApi);
+    }
+
+    return INTERRUPT_POLL_MS;
+}
+} // namespace
+
+// Helper to safely set response result
+static inline void setResponseError(meshtastic_SerialHalResponse &response, meshtastic_SerialHalResponse_Result result,
+                                    const char *error = nullptr)
+{
+    response.result = result;
+    if (error != nullptr) {
+        snprintf(response.error, sizeof(response.error), "%s", error);
+    }
+}
+
+void SerialHalDevice::handleCommand(const uint8_t *buf, size_t len, StreamAPI *streamApi)
+{
+    if (buf == nullptr || streamApi == nullptr) {
+        return;
+    }
+
+    // Validate role - SerialHal commands only handled when config.lora.serial_hal_only
+    if (!config.lora.serial_hal_only) {
+        meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+        response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+        snprintf(response.error, sizeof(response.error), "SerialHal not enabled for this role");
+        emitResponse(response, streamApi);
+        return;
+    }
+
+    // Decode the command
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    if (!pb_decode_from_bytes(buf, len, &meshtastic_SerialHalCommand_msg, &cmd)) {
+        meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+        response.result = meshtastic_SerialHalResponse_Result_BAD_REQUEST;
+        snprintf(response.error, sizeof(response.error), "Failed to decode SerialHalCommand");
+        emitResponse(response, streamApi);
+        return;
+    }
+
+    // Initialize response with matching transaction_id
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    response.transaction_id = cmd.transaction_id;
+    response.result = meshtastic_SerialHalResponse_Result_OK;
+
+    // Dispatch to operation handler
+    switch (cmd.type) {
+    case meshtastic_SerialHalCommand_Type_PIN_MODE:
+        handlePinMode(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DIGITAL_WRITE:
+        handleDigitalWrite(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DIGITAL_READ:
+        handleDigitalRead(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT:
+        handleAttachInterrupt(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT:
+        handleDetachInterrupt(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_SPI_TRANSFER:
+        handleSpiTransfer(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_NOOP:
+        // NOOP: just return OK
+        break;
+    default:
+        response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+        snprintf(response.error, sizeof(response.error), "Unknown SerialHal operation type");
+        break;
+    }
+
+    emitResponse(response, streamApi);
+}
+
+void SerialHalDevice::handlePinMode(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: pinMode pin=%u mode=%u", cmd.pin, cmd.mode);
+    if (cmd.mode == SERIAL_PI_INPUT) {
+        pinMode((int)cmd.pin, INPUT);
+    } else if (cmd.mode == SERIAL_PI_OUTPUT) {
+        pinMode((int)cmd.pin, OUTPUT);
+    } else {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_BAD_REQUEST, "Unsupported pin mode");
+    }
+}
+
+void SerialHalDevice::handleDigitalWrite(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: digitalWrite pin=%u value=%u", cmd.pin, cmd.value);
+    digitalWrite((int)cmd.pin, cmd.value ? HIGH : LOW);
+}
+
+void SerialHalDevice::handleDigitalRead(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: digitalRead pin=%u", cmd.pin);
+    response.value = (uint32_t)digitalRead((int)cmd.pin);
+}
+
+void SerialHalDevice::handleAttachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: attachInterrupt pin=%u mode=%u", cmd.pin, cmd.mode);
+
+    ensureInterruptEmitter();
+
+    int slot = -1;
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        slot = findSlotByPinLocked(cmd.pin);
+        if (slot < 0) {
+            slot = allocateSlotLocked();
+        }
+
+        if (slot >= 0) {
+            interruptSlots[slot].used = true;
+            interruptSlots[slot].pin = cmd.pin;
+            interruptSlots[slot].mode = cmd.mode;
+            interruptSlots[slot].pending = false;
+        }
+    }
+
+    if (slot < 0) {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_ERROR, "No interrupt slots available");
+        return;
+    }
+
+    ::attachInterrupt((int)cmd.pin, isrTable[slot], toInterruptMode(cmd.mode));
+}
+
+void SerialHalDevice::handleDetachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: detachInterrupt pin=%u", cmd.pin);
+
+    ::detachInterrupt((int)cmd.pin);
+
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        const int slot = findSlotByPinLocked(cmd.pin);
+        if (slot >= 0) {
+            interruptSlots[slot] = InterruptSlot{};
+        }
+    }
+}
+
+void SerialHalDevice::handleSpiTransfer(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    if (cmd.data.size == 0) {
+        return;
+    }
+
+#if !ARCH_PORTDUINO
+    if (spiLock == nullptr) {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_ERROR, "SPI lock not initialized");
+        return;
+    }
+
+#if defined(HW_SPI1_DEVICE)
+    SPIClass &spiBus = SPI1;
+#else
+    SPIClass &spiBus = SPI;
+#endif
+
+    response.data.size = cmd.data.size;
+
+    {
+        concurrency::LockGuard guard(spiLock);
+        spiBus.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
+#ifdef ARCH_ESP32
+        spiBus.transferBytes(cmd.data.bytes, response.data.bytes, cmd.data.size);
+#else
+        spiBus.transfer(cmd.data.bytes, response.data.bytes, cmd.data.size);
+#endif
+        spiBus.endTransaction();
+    }
+#else
+    // SPI wiring is board/radio-specific; keep this explicit for now.
+    response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+    snprintf(response.error, sizeof(response.error), "SPI not supported on this platform");
+#endif
+}
+
+void SerialHalDevice::emitResponse(const meshtastic_SerialHalResponse &response, StreamAPI *streamApi)
+{
+    if (streamApi == nullptr) {
+        return;
+    }
+
+    // Encode the response
+    uint8_t encoded[meshtastic_SerialHalResponse_size] = {0};
+    const size_t responseLen =
+        pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_SerialHalResponse_msg, static_cast<const void *>(&response));
+
+    if (responseLen == 0 || responseLen > 0xFFFF) {
+        LOG_ERROR("SerialHalDevice: Failed to encode response (len=%zu)", responseLen);
+        return;
+    }
+
+    // Build frame with StreamAPI framing: START1 SERIALHAL_MAGIC LEN_H LEN_L [payload]
+    constexpr uint8_t START1 = 0x94;
+    constexpr uint8_t SERIALHAL_MAGIC = 0xA5;
+
+    uint8_t hdr[4];
+    hdr[0] = START1;
+    hdr[1] = SERIALHAL_MAGIC;
+    hdr[2] = (uint8_t)((responseLen >> 8) & 0xFF); // LEN_H
+    hdr[3] = (uint8_t)(responseLen & 0xFF);        // LEN_L
+
+    // Emit via StreamAPI (this uses the internal txBuf + framing)
+    streamApi->emitSerialHalResponse(hdr, sizeof(hdr), encoded, responseLen);
+
+    // Keep a recent stream instance so async interrupt events can be emitted.
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        interruptStreamApi = streamApi;
+    }
+}
@@ -0,0 +1,90 @@
+#pragma once
+
+#include "mesh/generated/meshtastic/serial_hal.pb.h"
+#include <cstdint>
+
+/**
+ * @brief Device-side handler for SerialHal GPIO/SPI operations over StreamAPI framing.
+ *
+ * This module decodes SerialHalCommand protobufs received from a host and executes
+ * the requested GPIO (pinMode, digitalWrite, digitalRead, attach/detachInterrupt) or
+ * SPI operations, then returns results via SerialHalResponse.
+ *
+ * Usage:
+ *  1. Override StreamAPI::handleSerialHalCommand() in a subclass
+ *  2. Call SerialHalDevice::handleCommand(buf, len, streamApi)
+ *  3. SerialHalDevice will decode, execute, and emit the response
+ *
+ * The handler is only active when config.lora.serial_hal_only is true.
+ */
+
+class StreamAPI; // forward declaration
+
+class SerialHalDevice
+{
+  public:
+    /**
+     * @brief Process a SerialHalCommand and emit a response.
+     *
+     * Decodes the protobuf, validates the operation, executes it on the device,
+     * and writes the response back via the StreamAPI instance.
+     *
+     * @param buf     Pointer to the encoded SerialHalCommand protobuf payload (not including framing)
+     * @param len     Length of the encoded payload
+     * @param streamApi Pointer to the StreamAPI instance (used for emitting responses)
+     */
+    static void handleCommand(const uint8_t *buf, size_t len, StreamAPI *streamApi);
+
+    /**
+     * @brief Emit a SerialHalResponse back to the host via StreamAPI framing.
+     *
+     * Encodes the response protobuf and sends it with proper framing (START1 SERIALHAL_MAGIC LEN_H LEN_L payload).
+     *
+     * @param response The response to send
+     * @param streamApi Pointer to the StreamAPI instance
+     */
+    static void emitResponse(const meshtastic_SerialHalResponse &response, StreamAPI *streamApi);
+
+  private:
+    /**
+     * @brief Execute a GPIO pinMode operation.
+     * @param cmd Decoded SerialHalCommand with PIN_MODE type
+     * @param response Response object to fill with result
+     */
+    static void handlePinMode(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a GPIO digitalWrite operation.
+     * @param cmd Decoded SerialHalCommand with DIGITAL_WRITE type
+     * @param response Response object to fill with result
+     */
+    static void handleDigitalWrite(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a GPIO digitalRead operation.
+     * @param cmd Decoded SerialHalCommand with DIGITAL_READ type
+     * @param response Response object to fill with result (value field contains read result)
+     */
+    static void handleDigitalRead(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute an attachInterrupt operation.
+     * @param cmd Decoded SerialHalCommand with ATTACH_INTERRUPT type
+     * @param response Response object to fill with result
+     */
+    static void handleAttachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a detachInterrupt operation.
+     * @param cmd Decoded SerialHalCommand with DETACH_INTERRUPT type
+     * @param response Response object to fill with result
+     */
+    static void handleDetachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute an SPI transfer operation.
+     * @param cmd Decoded SerialHalCommand with SPI_TRANSFER type and data to send
+     * @param response Response object to fill with result (data field contains received bytes)
+     */
+    static void handleSpiTransfer(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+};
@@ -1,12 +1,15 @@
 #include "StreamAPI.h"
 #include "PowerFSM.h"
 #include "RTC.h"
+#include "RedirectablePrint.h"
+#include "SerialHalDevice.h"
 #include "Throttle.h"
 #include "concurrency/LockGuard.h"
 #include "configuration.h"

 #define START1 0x94
 #define START2 0xc3
+#define SERIALHAL_MAGIC 0xa5 // second framing byte for SerialHal frames (START1 SH_MAGIC LEN_H LEN_L PAYLOAD)
 #define HEADER_LEN 4

 int32_t StreamAPI::runOncePart()
@@ -79,18 +82,29 @@ int32_t StreamAPI::handleRecStream(const char *buf, uint16_t bufLen)
        if (ptr == 0) { // looking for START1
            if (c != START1)
                rxPtr = 0;     // failed to find framing
-        } else if (ptr == 1) { // looking for START2
-            if (c != START2)
-                rxPtr = 0;                             // failed to find framing
+        } else if (ptr == 1) { // discriminate frame type on second byte
+            if (c == START2) {
+                rxIsSerialHal = false; // standard ToRadio frame
+                serialHalRxActive.store(false);
+                RedirectablePrint::setSerialHalLogSuppressed(false);
+            } else if (c == SERIALHAL_MAGIC) {
+                rxIsSerialHal = true; // SerialHal command frame
+                serialHalRxActive.store(true);
+                RedirectablePrint::setSerialHalLogSuppressed(true);
+            } else {
+                rxPtr = 0; // unrecognised second byte — not our frame
+                serialHalRxActive.store(false);
+                RedirectablePrint::setSerialHalLogSuppressed(false);
+            }
        } else if (ptr >= HEADER_LEN - 1) {            // we have at least read our 4 byte framing
            uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing

            // console->printf("len %d\n", len);

            if (ptr == HEADER_LEN - 1) {
-                // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
-                // protobuf also)
-                if (len > MAX_TO_FROM_RADIO_SIZE)
+                // we _just_ finished our 4 byte header, validate length now
+                uint32_t maxLen = rxIsSerialHal ? (uint32_t)meshtastic_SerialHalCommand_size : MAX_TO_FROM_RADIO_SIZE;
+                if (len > maxLen)
                    rxPtr = 0; // length is bogus, restart search for framing
            }

@@ -98,8 +112,16 @@ int32_t StreamAPI::handleRecStream(const char *buf, uint16_t bufLen)
                if (ptr + 1 >= len + HEADER_LEN) { // have we received all of the payload?
                    rxPtr = 0;                     // start over again on the next packet

-                    // If we didn't just fail the packet and we now have the right # of bytes, parse it
-                    handleToRadio(rxBuf + HEADER_LEN, len);
+                    // Dispatch based on which frame type we identified at byte 1
+                    if (rxIsSerialHal)
+                        handleSerialHalCommand(rxBuf + HEADER_LEN, len);
+                    else
+                        handleToRadio(rxBuf + HEADER_LEN, len);
+
+                    if (rxIsSerialHal)
+                        serialHalRxActive.store(false);
+                    if (rxIsSerialHal)
+                        RedirectablePrint::setSerialHalLogSuppressed(false);
                }
        }
    }
@@ -114,7 +136,12 @@ int32_t StreamAPI::readStream()
    if (!stream->available()) {
        // Nothing available this time, if the computer has talked to us recently, poll often, otherwise let CPU sleep a long time
        bool recentRx = Throttle::isWithinTimespanMs(lastRxMsec, 2000);
-        return recentRx ? 5 : 250;
+        if (!recentRx)
+            return 250; // Sleep a long time if we haven't heard from the computer in a while
+        if (serialHalRxActive.load())
+            return 0; // If we are in the middle of a SerialHal transaction, don't sleep at all because we want to be as
+                      // responsive as possible to incoming SerialHal bytes
+        return 5;     // Otherwise, poll frequently for new data
    } else {
        while (stream->available()) { // Currently we never want to block
            int cInt = stream->read();
@@ -135,18 +162,30 @@ int32_t StreamAPI::readStream()
            if (ptr == 0) { // looking for START1
                if (c != START1)
                    rxPtr = 0;     // failed to find framing
-            } else if (ptr == 1) { // looking for START2
-                if (c != START2)
-                    rxPtr = 0;                             // failed to find framing
+            } else if (ptr == 1) { // discriminate frame type on second byte
+                if (c == START2) {
+                    rxIsSerialHal = false; // standard ToRadio frame
+                    serialHalRxActive.store(false);
+                    RedirectablePrint::setSerialHalLogSuppressed(false);
+                } else if (c == SERIALHAL_MAGIC) {
+                    rxIsSerialHal = true; // SerialHal command frame
+                    serialHalRxActive.store(true);
+                    RedirectablePrint::setSerialHalLogSuppressed(true);
+                    LOG_WARN("StreamAPI: Detected SerialHal command frame");
+                } else {
+                    rxPtr = 0; // unrecognised second byte — not our frame
+                    serialHalRxActive.store(false);
+                    RedirectablePrint::setSerialHalLogSuppressed(false);
+                }
            } else if (ptr >= HEADER_LEN - 1) {            // we have at least read our 4 byte framing
                uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing

                // console->printf("len %d\n", len);

                if (ptr == HEADER_LEN - 1) {
-                    // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
-                    // protobuf also)
-                    if (len > MAX_TO_FROM_RADIO_SIZE)
+                    // we _just_ finished our 4 byte header, validate length now
+                    uint32_t maxLen = rxIsSerialHal ? (uint32_t)meshtastic_SerialHalCommand_size : MAX_TO_FROM_RADIO_SIZE;
+                    if (len > maxLen)
                        rxPtr = 0; // length is bogus, restart search for framing
                }

@@ -154,8 +193,16 @@ int32_t StreamAPI::readStream()
                    if (ptr + 1 >= len + HEADER_LEN) { // have we received all of the payload?
                        rxPtr = 0;                     // start over again on the next packet

-                        // If we didn't just fail the packet and we now have the right # of bytes, parse it
-                        handleToRadio(rxBuf + HEADER_LEN, len);
+                        // Dispatch based on which frame type we identified at byte 1
+                        if (rxIsSerialHal)
+                            handleSerialHalCommand(rxBuf + HEADER_LEN, len);
+                        else
+                            handleToRadio(rxBuf + HEADER_LEN, len);
+
+                        if (rxIsSerialHal)
+                            serialHalRxActive.store(false);
+                        if (rxIsSerialHal)
+                            RedirectablePrint::setSerialHalLogSuppressed(false);
                    }
            }
        }
@@ -199,6 +246,10 @@ void StreamAPI::emitRebooted()

 void StreamAPI::emitLogRecord(meshtastic_LogRecord_Level level, const char *src, const char *format, va_list arg)
 {
+    if (serialHalRxActive.load()) {
+        return;
+    }
+
    // IMPORTANT: do NOT touch `fromRadioScratch` or `txBuf` here — those
    // belong to the main packet-emission path and a LOG_ firing during
    // `writeStream()` would corrupt an in-flight encode. We keep a
@@ -249,4 +300,31 @@ void StreamAPI::onConnectionChanged(bool connected)
        // received a packet in a while
        powerFSM.trigger(EVENT_SERIAL_DISCONNECTED);
    }
+}
+
+void StreamAPI::handleSerialHalCommand(const uint8_t *buf, size_t len)
+{
+    // Default implementation: dispatch to SerialHalDevice for GPIO/SPI handling
+    SerialHalDevice::handleCommand(buf, len, this);
+}
+
+void StreamAPI::emitSerialHalResponse(const uint8_t *hdr, size_t hdrLen, const uint8_t *payload, size_t payloadLen)
+{
+    if (hdr == nullptr || hdrLen != 4 || payload == nullptr || payloadLen > meshtastic_SerialHalResponse_size) {
+        LOG_ERROR("StreamAPI: Invalid SerialHal response parameters");
+        return;
+    }
+
+    // Build complete frame in a temporary buffer
+    uint8_t frame[4 + meshtastic_SerialHalResponse_size];
+    memcpy(frame, hdr, hdrLen);
+    memcpy(frame + hdrLen, payload, payloadLen);
+
+    size_t totalLen = hdrLen + payloadLen;
+
+    // Serialize stream writes against other emit operations via streamLock
+    concurrency::LockGuard guard(&streamLock);
+    stream->write(frame, totalLen);
+    stream->flush();
+    LOG_WARN("StreamAPI: Emitted SerialHal response frame (len=%zu)", totalLen);
 }
@@ -4,10 +4,15 @@
 #include "Stream.h"
 #include "concurrency/Lock.h"
 #include "concurrency/OSThread.h"
+#include "generated/meshtastic/serial_hal.pb.h"
+#include <atomic>
 #include <cstdarg>

-// A To/FromRadio packet + our 32 bit header
-#define MAX_STREAM_BUF_SIZE (MAX_TO_FROM_RADIO_SIZE + sizeof(uint32_t))
+// Buffer sized for the larger of a full ToRadio/FromRadio payload or a full SerialHalCommand payload, plus header.
+#define MAX_STREAM_PAYLOAD_SIZE                                                                                                  \
+    (MAX_TO_FROM_RADIO_SIZE > (int)meshtastic_SerialHalCommand_size ? MAX_TO_FROM_RADIO_SIZE                                     \
+                                                                    : (int)meshtastic_SerialHalCommand_size)
+#define MAX_STREAM_BUF_SIZE (MAX_STREAM_PAYLOAD_SIZE + (int)sizeof(uint32_t))

 /**
 * A version of our 'phone' API that talks over a Stream.  So therefore well suited to use with serial links
@@ -39,6 +44,8 @@ class StreamAPI : public PhoneAPI

    uint8_t rxBuf[MAX_STREAM_BUF_SIZE] = {0};
    size_t rxPtr = 0;
+    bool rxIsSerialHal = false; ///< true when the current in-progress frame is a SerialHal frame (START1 SH_MAGIC ...)
+    std::atomic<bool> serialHalRxActive{false};

    /// time of last rx, used, to slow down our polling if we haven't heard from anyone
    uint32_t lastRxMsec = 0;
@@ -56,6 +63,17 @@ class StreamAPI : public PhoneAPI
    /// Check the current underlying physical link to see if the client is currently connected
    virtual bool checkIsConnected() override = 0;

+    /**
+     * Emit a SerialHal response frame with proper framing (START1 SERIALHAL_MAGIC LEN_H LEN_L payload).
+     * Called by SerialHalDevice to send responses back to the host.
+     *
+     * @param hdr     4-byte header (START1 SERIALHAL_MAGIC LEN_H LEN_L)
+     * @param hdrLen  Length of header (should be 4)
+     * @param payload Encoded SerialHalResponse protobuf payload
+     * @param payloadLen Length of payload
+     */
+    void emitSerialHalResponse(const uint8_t *hdr, size_t hdrLen, const uint8_t *payload, size_t payloadLen);
+
  private:
    /**
     * Read any rx chars from the link and call handleToRadio
@@ -75,6 +93,12 @@ class StreamAPI : public PhoneAPI
     */
    void emitRebooted();

+    /**
+     * Called when a complete SerialHal-framed packet has been received.
+     * Default implementation dispatches to SerialHalDevice for GPIO/SPI handling.
+     */
+    virtual void handleSerialHalCommand(const uint8_t *buf, size_t len);
+
    virtual void onConnectionChanged(bool connected) override;

    /**
@@ -12,7 +12,12 @@

 #if defined(NRF52840_XXAA)
 #include "flash/flash_nrf5x.h"
-#define WARM_RING_MAGIC 0x474E5257u // "WRNG"
+#define WARM_RING_MAGIC 0x324E5257u    // "WRN2" — v2: last_heard low bits carry role + protected category
+#define WARM_RING_MAGIC_V1 0x474E5257u // "WRNG" — v1: last_heard was a plain timestamp.
+// v1 pages are still read on upgrade: we keep each record's identity + public key but
+// DISCARD its last_heard (the old timestamp would be misread as role/protected bits).
+// Records re-rank and re-learn their role on the next contact. Legacy pages convert to
+// v2 naturally as the ring rotates.
 // A tombstone is an entry record whose last_heard is all-ones — getTime()
 // (unix seconds) cannot reach 0xFFFFFFFF until 2106, and erased flash is
 // detected via num == 0xFFFFFFFF before last_heard is ever inspected.
@@ -28,7 +33,10 @@ struct WarmStoreHeader {
 };
 static_assert(sizeof(WarmStoreHeader) == 16, "header layout is part of the persistence format");

-#define WARM_STORE_MAGIC 0x314D5257u // "WRM1"
+#define WARM_STORE_MAGIC 0x324D5257u // "WRM2" — v2: last_heard low bits carry role + protected category
+#define WARM_STORE_MAGIC_V1                                                                                                      \
+    0x314D5257u // "WRM1" — v1: last_heard was a plain timestamp. On upgrade we keep
+                // identity + key but discard last_heard, then rewrite as v2.

 #ifdef FSCom
 static const char *warmFileName = "/prefs/warm.dat";
@@ -96,11 +104,13 @@ WarmNodeEntry *WarmNodeStore::place(NodeNum num, uint32_t lastHeard, const uint8
                slot = &e;
                break;
            }
+            // Compare on the time bits only — the low metadata bits (role/protected) must
+            // not perturb LRU victim selection.
            if (keyIsSet(e.public_key)) {
-                if (!oldestKeyed || e.last_heard < oldestKeyed->last_heard)
+                if (!oldestKeyed || warmTimeOf(e) < warmTimeOf(*oldestKeyed))
                    oldestKeyed = &e;
            } else {
-                if (!oldestKeyless || e.last_heard < oldestKeyless->last_heard)
+                if (!oldestKeyless || warmTimeOf(e) < warmTimeOf(*oldestKeyless))
                    oldestKeyless = &e;
            }
        }
@@ -121,14 +131,28 @@ WarmNodeEntry *WarmNodeStore::place(NodeNum num, uint32_t lastHeard, const uint8
    return slot;
 }

-bool WarmNodeStore::absorb(NodeNum num, uint32_t lastHeard, const uint8_t *key32)
+bool WarmNodeStore::absorb(NodeNum num, uint32_t lastHeard, const uint8_t *key32, uint8_t role, uint8_t protectedCat)
 {
-    const WarmNodeEntry *slot = place(num, lastHeard, key32);
+    // Pack role + protected category into the low bits of last_heard. place() and ring
+    // replay store the raw word verbatim, so the metadata round-trips through flash.
+    const uint32_t packed = warmPackLastHeard(lastHeard, role, protectedCat);
+    const WarmNodeEntry *slot = place(num, packed, key32);
    if (!slot)
        return false;
    persistEntry(*slot);
-    LOG_MIGRATION("WarmStore absorb 0x%08x key=%d last_heard=%u (now %u/%u)", (unsigned)num, keyIsSet(slot->public_key) ? 1 : 0,
-                  (unsigned)lastHeard, (unsigned)count(), (unsigned)capacity());
+    LOG_MIGRATION("WarmStore absorb 0x%08x key=%d last_heard=%u role=%u prot=%u (now %u/%u)", (unsigned)num,
+                  keyIsSet(slot->public_key) ? 1 : 0, (unsigned)warmTimeOf(*slot), (unsigned)role, (unsigned)protectedCat,
+                  (unsigned)count(), (unsigned)capacity());
+    return true;
+}
+
+bool WarmNodeStore::lookupMeta(NodeNum num, uint8_t &role, uint8_t &protectedCat) const
+{
+    const WarmNodeEntry *e = find(num);
+    if (!e)
+        return false;
+    role = warmRoleOf(*e);
+    protectedCat = warmProtOf(*e);
    return true;
 }

@@ -231,10 +255,22 @@ bool WarmNodeStore::saveIfDirty()
 // (stranded live entries re-appended, then erased). Flash access holds spiLock —
 // the page cache is shared with InternalFS/LittleFS.

-bool WarmNodeStore::ringReadHeader(uint8_t page, WarmPageHeader &h) const
+bool WarmNodeStore::ringReadHeader(uint8_t page, WarmPageHeader &h, bool *legacy) const
 {
    flash_nrf5x_read(&h, WARM_FLASH_PAGE_ADDR(page), sizeof(h));
-    return h.magic == WARM_RING_MAGIC && h.seq != 0xFFFFFFFFu;
+    if (h.seq == 0xFFFFFFFFu)
+        return false; // erased page
+    if (h.magic == WARM_RING_MAGIC) {
+        if (legacy)
+            *legacy = false;
+        return true;
+    }
+    if (h.magic == WARM_RING_MAGIC_V1) {
+        if (legacy)
+            *legacy = true; // v1 page: replay it, but discard last_heard (see WARM_RING_MAGIC_V1)
+        return true;
+    }
+    return false;
 }

 // Caller holds spiLock.
@@ -347,11 +383,13 @@ void WarmNodeStore::load()
    // Order valid pages by ascending seq so replay applies oldest first
    uint8_t order[WARM_FLASH_PAGES] = {};
    uint32_t seqs[WARM_FLASH_PAGES] = {};
+    bool legacyOf[WARM_FLASH_PAGES] = {}; // per-page: v1 (WRNG) → discard last_heard on replay
    uint8_t nValid = 0;
    uint8_t nCorrupt = 0;
    for (uint8_t p = 0; p < WARM_FLASH_PAGES; p++) {
        WarmPageHeader h;
-        if (!ringReadHeader(p, h)) {
+        bool legacy = false;
+        if (!ringReadHeader(p, h, &legacy)) {
            // An erased page reads back all-ones; any other magic is a
            // partially-written or bit-rotted header we're dropping, so flag it
            // rather than silently treating the loss as a clean empty ring.
@@ -359,6 +397,7 @@ void WarmNodeStore::load()
                nCorrupt++;
            continue;
        }
+        legacyOf[p] = legacy;
        uint8_t pos = nValid;
        while (pos > 0 && static_cast<int32_t>(h.seq - seqs[pos - 1]) < 0) {
            order[pos] = order[pos - 1];
@@ -382,8 +421,10 @@ void WarmNodeStore::load()
    }

    uint32_t replayed = 0;
+    uint32_t migrated = 0;
    for (uint8_t k = 0; k < nValid; k++) {
        const uint8_t p = order[k];
+        const bool legacy = legacyOf[p];
        uint16_t slot = 0;
        for (; slot < kRecordsPerPage; slot++) {
            WarmNodeEntry rec;
@@ -400,7 +441,14 @@ void WarmNodeStore::load()
                    memset(e, 0, sizeof(*e));
                }
            } else {
-                const WarmNodeEntry *e = place(rec.num, rec.last_heard, rec.public_key);
+                // v1 (legacy) record: keep identity + key, but discard the old timestamp —
+                // its low bits would otherwise be misread as role/protected metadata.
+                uint32_t lh = rec.last_heard;
+                if (legacy) {
+                    lh = 0;
+                    migrated++;
+                }
+                const WarmNodeEntry *e = place(rec.num, lh, rec.public_key);
                if (e)
                    pageOf[e - entries] = p;
            }
@@ -409,10 +457,17 @@ void WarmNodeStore::load()
            activePage = p;
            writeSlot = slot;
            nextSeq = seqs[k] + 1;
+            // If the head is a v1 page, force the next append to rotate into a fresh v2 page,
+            // so new (v2) records never land in a page whose header says v1 (which would make
+            // a later load discard their last_heard — including the role/protected we just set).
+            if (legacy)
+                writeSlot = kRecordsPerPage;
        }
    }
    if (nCorrupt)
        LOG_WARN("WarmStore: dropped %u corrupt ring page(s), some nodes lost", nCorrupt);
+    if (migrated)
+        LOG_INFO("WarmStore: migrated %u v1 record(s) (kept key, discarded last_heard)", (unsigned)migrated);
    LOG_INFO("WarmStore: replayed %u ring records -> %u live nodes (page %u, slot %u)", (unsigned)replayed, (unsigned)count(),
             activePage, writeSlot);
 }
@@ -479,7 +534,10 @@ void WarmNodeStore::load()
        LOG_WARN("WarmStore: %s header read failed, starting empty", warmFileName);
        return;
    }
-    if (h.magic != WARM_STORE_MAGIC || h.entrySize != sizeof(WarmNodeEntry) || h.count > WARM_NODE_COUNT) {
+    // v1 (WRM1) is still accepted: same record size, but its last_heard was a plain
+    // timestamp. We keep identity + key and discard last_heard on load (see below).
+    const bool legacy = (h.magic == WARM_STORE_MAGIC_V1);
+    if ((h.magic != WARM_STORE_MAGIC && !legacy) || h.entrySize != sizeof(WarmNodeEntry) || h.count > WARM_NODE_COUNT) {
        f.close();
        LOG_WARN("WarmStore: %s header invalid (magic=0x%08x entrySize=%u count=%u), starting empty", warmFileName, h.magic,
                 h.entrySize, h.count);
@@ -493,14 +551,25 @@ void WarmNodeStore::load()
            LOG_WARN("WarmStore: %s entries read failed, starting empty", warmFileName);
            return;
        }
+        // CRC covers the bytes as written (v1 still has the old last_heard), so check before migrating.
        if (crc32Buffer(entries, len) != h.crc) {
            LOG_WARN("WarmStore: %s CRC mismatch, starting empty", warmFileName);
+            memset(entries, 0, WARM_NODE_COUNT * sizeof(WarmNodeEntry));
            return;
        }
+        if (legacy) {
+            // Migrate v1 → v2: discard the old last_heard (its low bits would be misread as
+            // role/protected); keep num + public_key. Mark dirty so save() rewrites as v2.
+            for (size_t i = 0; i < WARM_NODE_COUNT; i++)
+                if (entries[i].num)
+                    entries[i].last_heard = 0;
+            dirty = true;
+        }
    } else {
        f.close();
    }
-    LOG_INFO("WarmStore: loaded %u warm nodes from %s", h.count, warmFileName);
+    LOG_INFO("WarmStore: loaded %u warm nodes from %s%s", h.count, warmFileName,
+             legacy ? " (v1 migrated: discarded last_heard)" : "");
 }

 bool WarmNodeStore::save()
@@ -34,11 +34,50 @@
 */
 struct WarmNodeEntry {
    NodeNum num;            // 0 = empty slot
-    uint32_t last_heard;    // recency for LRU ordering
+    uint32_t last_heard;    // recency for LRU ordering — see the metadata steal below
    uint8_t public_key[32]; // all-zero = no key (a real key is never all-zero)
 };
 static_assert(sizeof(WarmNodeEntry) == 40, "WarmNodeEntry must stay 40 B — persistence format depends on it");

+// Metadata packed into the low bits of last_heard.
+//
+// The warm tier only uses last_heard to LRU-rank evicted (long-tail) nodes, so ~minute
+// recency resolution is plenty. We reclaim the low WARM_META_BITS of that field to carry
+// the evicted node's device role + a protected category, at zero cost to record size
+// (entry stays 40 B; no RAM/flash growth). The high bits remain a real unix-seconds
+// timestamp quantised to (1 << WARM_META_BITS) seconds.
+//
+// Safe because: a real timestamp can never be all-ones (the tombstone sentinel) before
+// 2106, and tombstones/erased flash are detected via num before last_heard is read. Only
+// the LOW bits are stolen — the high (era) bits are untouched, so the time range is intact.
+static constexpr uint32_t WARM_META_BITS = 6;                          // role(4) + protected(2)
+static constexpr uint32_t WARM_META_MASK = (1u << WARM_META_BITS) - 1; // 0x3F → 64 s quantum
+static constexpr uint32_t WARM_TIME_MASK = ~WARM_META_MASK;            // 0xFFFFFFC0
+static constexpr uint32_t WARM_ROLE_MASK = 0x0Fu;                      // bits [3:0] device role (0..12)
+static constexpr uint32_t WARM_PROT_SHIFT = 4;                         // bits [5:4] protected category
+static constexpr uint32_t WARM_PROT_MASK = 0x03u;
+
+// Protected category cached alongside role so consumers needn't re-derive the mapping.
+enum class WarmProtected : uint8_t { None = 0, Role = 1, Flag = 2 };
+
+inline uint32_t warmPackLastHeard(uint32_t lastHeard, uint8_t role, uint8_t prot)
+{
+    return (lastHeard & WARM_TIME_MASK) | (static_cast<uint32_t>(role) & WARM_ROLE_MASK) |
+           ((static_cast<uint32_t>(prot) & WARM_PROT_MASK) << WARM_PROT_SHIFT);
+}
+inline uint32_t warmTimeOf(const WarmNodeEntry &e)
+{
+    return e.last_heard & WARM_TIME_MASK;
+}
+inline uint8_t warmRoleOf(const WarmNodeEntry &e)
+{
+    return static_cast<uint8_t>(e.last_heard & WARM_ROLE_MASK);
+}
+inline uint8_t warmProtOf(const WarmNodeEntry &e)
+{
+    return static_cast<uint8_t>((e.last_heard >> WARM_PROT_SHIFT) & WARM_PROT_MASK);
+}
+
 // Gated on NRF52840_XXAA: the ring sits at 0xEA000
 // valid only on the 1 MB-flash nRF52840.
 #if defined(NRF52840_XXAA)
@@ -58,8 +97,15 @@ class WarmNodeStore

    /// Remember an evicted hot node. Keyless candidates never displace keyed
    /// entries; otherwise the oldest (keyless-first) entry is replaced.
+    /// @param role         the node's device role (meshtastic_Config_DeviceConfig_Role, 0..12)
+    /// @param protectedCat WarmProtected category cached for the hop-trim path
    /// @return true if the node was stored or updated
-    bool absorb(NodeNum num, uint32_t lastHeard, const uint8_t *key32 /* may be NULL */);
+    bool absorb(NodeNum num, uint32_t lastHeard, const uint8_t *key32 /* may be NULL */, uint8_t role = 0,
+                uint8_t protectedCat = 0);
+
+    /// Look up the cached device role + protected category for a warm node.
+    /// @return false if the node is not in the warm tier.
+    bool lookupMeta(NodeNum num, uint8_t &role, uint8_t &protectedCat) const;

    /// Find and remove an entry (used when the node is re-admitted to the hot store).
    bool take(NodeNum num, WarmNodeEntry &out);
@@ -121,7 +167,7 @@ class WarmNodeStore
    void ringAppend(const WarmNodeEntry &rec, int storeSlot /* -1 for tombstones */);
    void ringRotate();               // reclaim oldest page, compacting stranded live entries
    void ringOpenPage(uint8_t page); // erase + write header (seq = nextSeq++)
-    bool ringReadHeader(uint8_t page, WarmPageHeader &h) const;
+    bool ringReadHeader(uint8_t page, WarmPageHeader &h, bool *legacy = nullptr) const;
 #endif

    bool save();
@@ -452,7 +452,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2432
+#define meshtastic_BackupPreferences_size        2410
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1944
 #define meshtastic_NodeEnvironmentEntry_size     170
@@ -206,7 +206,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;
 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
 #define meshtastic_LocalConfig_size              757
-#define meshtastic_LocalModuleConfig_size        820
+#define meshtastic_LocalModuleConfig_size        798

 #ifdef __cplusplus
 } /* extern "C" */
@@ -96,6 +96,15 @@ PB_BIND(meshtastic_Neighbor, meshtastic_Neighbor, AUTO)
 PB_BIND(meshtastic_DeviceMetadata, meshtastic_DeviceMetadata, AUTO)


+PB_BIND(meshtastic_LoRaPresetGroup, meshtastic_LoRaPresetGroup, AUTO)
+
+
+PB_BIND(meshtastic_LoRaRegionPresets, meshtastic_LoRaRegionPresets, AUTO)
+
+
+PB_BIND(meshtastic_LoRaRegionPresetMap, meshtastic_LoRaRegionPresetMap, 2)
+
+
 PB_BIND(meshtastic_Heartbeat, meshtastic_Heartbeat, AUTO)


@@ -1355,6 +1355,53 @@ typedef struct _meshtastic_DeviceMetadata {
    uint32_t excluded_modules;
 } meshtastic_DeviceMetadata;

+/* A distinct set of legal modem presets shared by one or more LoRa regions.
+ Regions that have an identical preset list / default / licensing reference
+ the same group (by index) via LoRaRegionPresetMap.region_groups. This keeps
+ the whole map small enough to fit in a single FromRadio packet, since most
+ regions share the one standard preset list. */
+typedef struct _meshtastic_LoRaPresetGroup {
+    /* The modem presets that are legal for every region referencing this group. */
+    pb_size_t presets_count;
+    meshtastic_Config_LoRaConfig_ModemPreset presets[11];
+    /* The firmware's default modem preset for regions in this group.
+ Always one of `presets`. Clients should select this when switching to one
+ of these regions, or when the current preset is not legal in the new region. */
+    meshtastic_Config_LoRaConfig_ModemPreset default_preset;
+    /* True if regions referencing this group are for licensed operators only
+ (e.g. amateur / ham radio bands). Clients should warn or gate accordingly. */
+    bool licensed_only;
+} meshtastic_LoRaPresetGroup;
+
+/* Associates a single LoRa region with its preset group. */
+typedef struct _meshtastic_LoRaRegionPresets {
+    /* The LoRa region this entry describes. */
+    meshtastic_Config_LoRaConfig_RegionCode region;
+    /* Index into LoRaRegionPresetMap.groups for the preset list that is legal
+ in `region`. */
+    uint8_t group_index;
+} meshtastic_LoRaRegionPresets;
+
+/* Map describing which modem presets are valid for each LoRa region. Sent by
+ the firmware during the want_config handshake (as FromRadio.region_presets)
+ so that client UIs can prevent illegal region+preset selections.
+
+ Delivery is grouped to save space: `groups` holds each distinct preset list,
+ and `region_groups` maps every known region to one of those groups by index.
+ A region that does NOT appear in `region_groups` carries no constraint
+ information and should not be restricted by the client (e.g. firmware that
+ predates this message, or a region with no firmware table entry). Clients
+ must also tolerate this whole message being absent. */
+typedef struct _meshtastic_LoRaRegionPresetMap {
+    /* One entry per distinct (preset-list, default, licensing) combination.
+ Referenced by index from `region_groups`. */
+    pb_size_t groups_count;
+    meshtastic_LoRaPresetGroup groups[8];
+    /* One entry per known LoRa region, pointing at its preset group. */
+    pb_size_t region_groups_count;
+    meshtastic_LoRaRegionPresets region_groups[38];
+} meshtastic_LoRaRegionPresetMap;
+
 /* Packets from the radio to the phone will appear on the fromRadio characteristic.
 It will support READ and NOTIFY. When a new packet arrives the device will BLE notify?
 It will sit in that descriptor until consumed by the phone,
@@ -1411,6 +1458,12 @@ typedef struct _meshtastic_FromRadio {
     to report success or failure. Replaces the earlier scheme of
     encoding state as magic-string prefixes inside ClientNotification. */
        meshtastic_LockdownStatus lockdown_status;
+        /* Map of which modem presets are legal in each LoRa region. Sent once
+     during the want_config handshake (right after `metadata`, before the
+     first `channel`) so client UIs can prevent the user from selecting an
+     illegal region+preset combination. A region that does not appear in
+     any group carries no constraint info and should not be restricted. */
+        meshtastic_LoRaRegionPresetMap region_presets;
    };
 } meshtastic_FromRadio;

@@ -1604,6 +1657,12 @@ extern "C" {
 #define meshtastic_DeviceMetadata_role_ENUMTYPE meshtastic_Config_DeviceConfig_Role
 #define meshtastic_DeviceMetadata_hw_model_ENUMTYPE meshtastic_HardwareModel

+#define meshtastic_LoRaPresetGroup_presets_ENUMTYPE meshtastic_Config_LoRaConfig_ModemPreset
+#define meshtastic_LoRaPresetGroup_default_preset_ENUMTYPE meshtastic_Config_LoRaConfig_ModemPreset
+
+#define meshtastic_LoRaRegionPresets_region_ENUMTYPE meshtastic_Config_LoRaConfig_RegionCode
+
+



@@ -1641,6 +1700,9 @@ extern "C" {
 #define meshtastic_NeighborInfo_init_default     {0, 0, 0, 0, {meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default, meshtastic_Neighbor_init_default}}
 #define meshtastic_Neighbor_init_default         {0, 0, 0, 0}
 #define meshtastic_DeviceMetadata_init_default   {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN, 0, 0, 0}
+#define meshtastic_LoRaPresetGroup_init_default  {0, {_meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN}, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0}
+#define meshtastic_LoRaRegionPresets_init_default {_meshtastic_Config_LoRaConfig_RegionCode_MIN, 0}
+#define meshtastic_LoRaRegionPresetMap_init_default {0, {meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default, meshtastic_LoRaPresetGroup_init_default}, 0, {meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default, meshtastic_LoRaRegionPresets_init_default}}
 #define meshtastic_Heartbeat_init_default        {0}
 #define meshtastic_NodeRemoteHardwarePin_init_default {0, false, meshtastic_RemoteHardwarePin_init_default}
 #define meshtastic_ChunkedPayload_init_default   {0, 0, 0, {0, {0}}}
@@ -1676,6 +1738,9 @@ extern "C" {
 #define meshtastic_NeighborInfo_init_zero        {0, 0, 0, 0, {meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero, meshtastic_Neighbor_init_zero}}
 #define meshtastic_Neighbor_init_zero            {0, 0, 0, 0}
 #define meshtastic_DeviceMetadata_init_zero      {"", 0, 0, 0, 0, 0, _meshtastic_Config_DeviceConfig_Role_MIN, 0, _meshtastic_HardwareModel_MIN, 0, 0, 0}
+#define meshtastic_LoRaPresetGroup_init_zero     {0, {_meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, _meshtastic_Config_LoRaConfig_ModemPreset_MIN}, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0}
+#define meshtastic_LoRaRegionPresets_init_zero   {_meshtastic_Config_LoRaConfig_RegionCode_MIN, 0}
+#define meshtastic_LoRaRegionPresetMap_init_zero {0, {meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero, meshtastic_LoRaPresetGroup_init_zero}, 0, {meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero, meshtastic_LoRaRegionPresets_init_zero}}
 #define meshtastic_Heartbeat_init_zero           {0}
 #define meshtastic_NodeRemoteHardwarePin_init_zero {0, false, meshtastic_RemoteHardwarePin_init_zero}
 #define meshtastic_ChunkedPayload_init_zero      {0, 0, 0, {0, {0}}}
@@ -1866,6 +1931,13 @@ extern "C" {
 #define meshtastic_DeviceMetadata_hasRemoteHardware_tag 10
 #define meshtastic_DeviceMetadata_hasPKC_tag     11
 #define meshtastic_DeviceMetadata_excluded_modules_tag 12
+#define meshtastic_LoRaPresetGroup_presets_tag   1
+#define meshtastic_LoRaPresetGroup_default_preset_tag 2
+#define meshtastic_LoRaPresetGroup_licensed_only_tag 3
+#define meshtastic_LoRaRegionPresets_region_tag  1
+#define meshtastic_LoRaRegionPresets_group_index_tag 2
+#define meshtastic_LoRaRegionPresetMap_groups_tag 1
+#define meshtastic_LoRaRegionPresetMap_region_groups_tag 2
 #define meshtastic_FromRadio_id_tag              1
 #define meshtastic_FromRadio_packet_tag          2
 #define meshtastic_FromRadio_my_info_tag         3
@@ -1884,6 +1956,7 @@ extern "C" {
 #define meshtastic_FromRadio_clientNotification_tag 16
 #define meshtastic_FromRadio_deviceuiConfig_tag  17
 #define meshtastic_FromRadio_lockdown_status_tag 18
+#define meshtastic_FromRadio_region_presets_tag  19
 #define meshtastic_Heartbeat_nonce_tag           1
 #define meshtastic_ToRadio_packet_tag            1
 #define meshtastic_ToRadio_want_config_id_tag    3
@@ -2128,7 +2201,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,mqttClientProxyMessage,mqttC
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,fileInfo,fileInfo),  15) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,clientNotification,clientNotification),  16) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,deviceuiConfig,deviceuiConfig),  17) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lockdown_status,lockdown_status),  18)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lockdown_status,lockdown_status),  18) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,region_presets,region_presets),  19)
 #define meshtastic_FromRadio_CALLBACK NULL
 #define meshtastic_FromRadio_DEFAULT NULL
 #define meshtastic_FromRadio_payload_variant_packet_MSGTYPE meshtastic_MeshPacket
@@ -2146,6 +2220,7 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payload_variant,lockdown_status,lockdown_sta
 #define meshtastic_FromRadio_payload_variant_clientNotification_MSGTYPE meshtastic_ClientNotification
 #define meshtastic_FromRadio_payload_variant_deviceuiConfig_MSGTYPE meshtastic_DeviceUIConfig
 #define meshtastic_FromRadio_payload_variant_lockdown_status_MSGTYPE meshtastic_LockdownStatus
+#define meshtastic_FromRadio_payload_variant_region_presets_MSGTYPE meshtastic_LoRaRegionPresetMap

 #define meshtastic_LockdownStatus_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UENUM,    state,             1) \
@@ -2264,6 +2339,27 @@ X(a, STATIC,   SINGULAR, UINT32,   excluded_modules,  12)
 #define meshtastic_DeviceMetadata_CALLBACK NULL
 #define meshtastic_DeviceMetadata_DEFAULT NULL

+#define meshtastic_LoRaPresetGroup_FIELDLIST(X, a) \
+X(a, STATIC,   REPEATED, UENUM,    presets,           1) \
+X(a, STATIC,   SINGULAR, UENUM,    default_preset,    2) \
+X(a, STATIC,   SINGULAR, BOOL,     licensed_only,     3)
+#define meshtastic_LoRaPresetGroup_CALLBACK NULL
+#define meshtastic_LoRaPresetGroup_DEFAULT NULL
+
+#define meshtastic_LoRaRegionPresets_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    region,            1) \
+X(a, STATIC,   SINGULAR, UINT32,   group_index,       2)
+#define meshtastic_LoRaRegionPresets_CALLBACK NULL
+#define meshtastic_LoRaRegionPresets_DEFAULT NULL
+
+#define meshtastic_LoRaRegionPresetMap_FIELDLIST(X, a) \
+X(a, STATIC,   REPEATED, MESSAGE,  groups,            1) \
+X(a, STATIC,   REPEATED, MESSAGE,  region_groups,     2)
+#define meshtastic_LoRaRegionPresetMap_CALLBACK NULL
+#define meshtastic_LoRaRegionPresetMap_DEFAULT NULL
+#define meshtastic_LoRaRegionPresetMap_groups_MSGTYPE meshtastic_LoRaPresetGroup
+#define meshtastic_LoRaRegionPresetMap_region_groups_MSGTYPE meshtastic_LoRaRegionPresets
+
 #define meshtastic_Heartbeat_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   nonce,             1)
 #define meshtastic_Heartbeat_CALLBACK NULL
@@ -2328,6 +2424,9 @@ extern const pb_msgdesc_t meshtastic_Compressed_msg;
 extern const pb_msgdesc_t meshtastic_NeighborInfo_msg;
 extern const pb_msgdesc_t meshtastic_Neighbor_msg;
 extern const pb_msgdesc_t meshtastic_DeviceMetadata_msg;
+extern const pb_msgdesc_t meshtastic_LoRaPresetGroup_msg;
+extern const pb_msgdesc_t meshtastic_LoRaRegionPresets_msg;
+extern const pb_msgdesc_t meshtastic_LoRaRegionPresetMap_msg;
 extern const pb_msgdesc_t meshtastic_Heartbeat_msg;
 extern const pb_msgdesc_t meshtastic_NodeRemoteHardwarePin_msg;
 extern const pb_msgdesc_t meshtastic_ChunkedPayload_msg;
@@ -2365,6 +2464,9 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_NeighborInfo_fields &meshtastic_NeighborInfo_msg
 #define meshtastic_Neighbor_fields &meshtastic_Neighbor_msg
 #define meshtastic_DeviceMetadata_fields &meshtastic_DeviceMetadata_msg
+#define meshtastic_LoRaPresetGroup_fields &meshtastic_LoRaPresetGroup_msg
+#define meshtastic_LoRaRegionPresets_fields &meshtastic_LoRaRegionPresets_msg
+#define meshtastic_LoRaRegionPresetMap_fields &meshtastic_LoRaRegionPresetMap_msg
 #define meshtastic_Heartbeat_fields &meshtastic_Heartbeat_msg
 #define meshtastic_NodeRemoteHardwarePin_fields &meshtastic_NodeRemoteHardwarePin_msg
 #define meshtastic_ChunkedPayload_fields &meshtastic_ChunkedPayload_msg
@@ -2388,6 +2490,9 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_KeyVerificationNumberInform_size 58
 #define meshtastic_KeyVerificationNumberRequest_size 52
 #define meshtastic_KeyVerification_size          79
+#define meshtastic_LoRaPresetGroup_size          26
+#define meshtastic_LoRaRegionPresetMap_size      490
+#define meshtastic_LoRaRegionPresets_size        5
 #define meshtastic_LockdownStatus_size           53
 #define meshtastic_LogRecord_size                426
 #define meshtastic_LowEntropyKey_size            0
@@ -232,34 +232,23 @@ typedef struct _meshtastic_ModuleConfig_PaxcounterConfig {
 /* Config for the Traffic Management module.
 Provides packet inspection and traffic shaping to help reduce channel utilization */
 typedef struct _meshtastic_ModuleConfig_TrafficManagementConfig {
-    /* Master enable for traffic management module */
-    bool enabled;
-    /* Enable position deduplication to drop redundant position broadcasts */
-    bool position_dedup_enabled;
-    /* Number of bits of precision for position deduplication (0-32) */
-    uint32_t position_precision_bits;
-    /* Minimum interval in seconds between position updates from the same node */
+    /* Minimum interval in seconds between position updates from the same node.
+ A non-zero value implicitly enables the suppression window; 0 disables it. */
    uint32_t position_min_interval_secs;
-    /* Enable direct response to NodeInfo requests from local cache */
-    bool nodeinfo_direct_response;
-    /* Minimum hop distance from requestor before responding to NodeInfo requests */
+    /* Maximum hop distance from the requestor at which direct NodeInfo responses
+ are served from the local cache. A non-zero value implicitly enables direct
+ response; 0 disables it. */
    uint32_t nodeinfo_direct_response_max_hops;
-    /* Enable per-node rate limiting to throttle chatty nodes */
-    bool rate_limit_enabled;
-    /* Time window in seconds for rate limiting calculations */
+    /* Time window in seconds for per-node rate limiting.
+ A non-zero value implicitly enables rate limiting; 0 disables it. */
    uint32_t rate_limit_window_secs;
-    /* Maximum packets allowed per node within the rate limit window */
+    /* Maximum packets allowed per node within the rate limit window.
+ A non-zero value implicitly enables rate limiting; 0 disables it. */
    uint32_t rate_limit_max_packets;
-    /* Enable dropping of unknown/undecryptable packets per rate_limit_window_secs */
-    bool drop_unknown_enabled;
-    /* Number of unknown packets before dropping from a node */
+    /* Maximum unknown/undecryptable packets per rate window before the source
+ is dropped. A non-zero value implicitly enables unknown-packet filtering;
+ 0 disables it. */
    uint32_t unknown_packet_threshold;
-    /* Set hop_limit to 0 for relayed telemetry broadcasts (own packets unaffected) */
-    bool exhaust_hop_telemetry;
-    /* Set hop_limit to 0 for relayed position broadcasts (own packets unaffected) */
-    bool exhaust_hop_position;
-    /* Preserve hop_limit for router-to-router traffic */
-    bool router_preserve_hops;
 } meshtastic_ModuleConfig_TrafficManagementConfig;

 /* Serial Config */
@@ -588,7 +577,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_DetectionSensorConfig_init_default {0, 0, 0, 0, "", 0, _meshtastic_ModuleConfig_DetectionSensorConfig_TriggerType_MIN, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_default {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_default {0, 0, 0, 0}
-#define meshtastic_ModuleConfig_TrafficManagementConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TrafficManagementConfig_init_default {0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_default {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_default {0, 0, 0, 0, 0, 0}
@@ -607,7 +596,7 @@ extern "C" {
 #define meshtastic_ModuleConfig_DetectionSensorConfig_init_zero {0, 0, 0, 0, "", 0, _meshtastic_ModuleConfig_DetectionSensorConfig_TriggerType_MIN, 0}
 #define meshtastic_ModuleConfig_AudioConfig_init_zero {0, 0, _meshtastic_ModuleConfig_AudioConfig_Audio_Baud_MIN, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_PaxcounterConfig_init_zero {0, 0, 0, 0}
-#define meshtastic_ModuleConfig_TrafficManagementConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+#define meshtastic_ModuleConfig_TrafficManagementConfig_init_zero {0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_SerialConfig_init_zero {0, 0, 0, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Baud_MIN, 0, _meshtastic_ModuleConfig_SerialConfig_Serial_Mode_MIN, 0}
 #define meshtastic_ModuleConfig_ExternalNotificationConfig_init_zero {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define meshtastic_ModuleConfig_StoreForwardConfig_init_zero {0, 0, 0, 0, 0, 0}
@@ -656,20 +645,11 @@ extern "C" {
 #define meshtastic_ModuleConfig_PaxcounterConfig_paxcounter_update_interval_tag 2
 #define meshtastic_ModuleConfig_PaxcounterConfig_wifi_threshold_tag 3
 #define meshtastic_ModuleConfig_PaxcounterConfig_ble_threshold_tag 4
-#define meshtastic_ModuleConfig_TrafficManagementConfig_enabled_tag 1
-#define meshtastic_ModuleConfig_TrafficManagementConfig_position_dedup_enabled_tag 2
-#define meshtastic_ModuleConfig_TrafficManagementConfig_position_precision_bits_tag 3
 #define meshtastic_ModuleConfig_TrafficManagementConfig_position_min_interval_secs_tag 4
-#define meshtastic_ModuleConfig_TrafficManagementConfig_nodeinfo_direct_response_tag 5
 #define meshtastic_ModuleConfig_TrafficManagementConfig_nodeinfo_direct_response_max_hops_tag 6
-#define meshtastic_ModuleConfig_TrafficManagementConfig_rate_limit_enabled_tag 7
 #define meshtastic_ModuleConfig_TrafficManagementConfig_rate_limit_window_secs_tag 8
 #define meshtastic_ModuleConfig_TrafficManagementConfig_rate_limit_max_packets_tag 9
-#define meshtastic_ModuleConfig_TrafficManagementConfig_drop_unknown_enabled_tag 10
 #define meshtastic_ModuleConfig_TrafficManagementConfig_unknown_packet_threshold_tag 11
-#define meshtastic_ModuleConfig_TrafficManagementConfig_exhaust_hop_telemetry_tag 12
-#define meshtastic_ModuleConfig_TrafficManagementConfig_exhaust_hop_position_tag 13
-#define meshtastic_ModuleConfig_TrafficManagementConfig_router_preserve_hops_tag 14
 #define meshtastic_ModuleConfig_SerialConfig_enabled_tag 1
 #define meshtastic_ModuleConfig_SerialConfig_echo_tag 2
 #define meshtastic_ModuleConfig_SerialConfig_rxd_tag 3
@@ -867,20 +847,11 @@ X(a, STATIC,   SINGULAR, INT32,    ble_threshold,     4)
 #define meshtastic_ModuleConfig_PaxcounterConfig_DEFAULT NULL

 #define meshtastic_ModuleConfig_TrafficManagementConfig_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, BOOL,     enabled,           1) \
-X(a, STATIC,   SINGULAR, BOOL,     position_dedup_enabled,   2) \
-X(a, STATIC,   SINGULAR, UINT32,   position_precision_bits,   3) \
 X(a, STATIC,   SINGULAR, UINT32,   position_min_interval_secs,   4) \
-X(a, STATIC,   SINGULAR, BOOL,     nodeinfo_direct_response,   5) \
 X(a, STATIC,   SINGULAR, UINT32,   nodeinfo_direct_response_max_hops,   6) \
-X(a, STATIC,   SINGULAR, BOOL,     rate_limit_enabled,   7) \
 X(a, STATIC,   SINGULAR, UINT32,   rate_limit_window_secs,   8) \
 X(a, STATIC,   SINGULAR, UINT32,   rate_limit_max_packets,   9) \
-X(a, STATIC,   SINGULAR, BOOL,     drop_unknown_enabled,  10) \
-X(a, STATIC,   SINGULAR, UINT32,   unknown_packet_threshold,  11) \
-X(a, STATIC,   SINGULAR, BOOL,     exhaust_hop_telemetry,  12) \
-X(a, STATIC,   SINGULAR, BOOL,     exhaust_hop_position,  13) \
-X(a, STATIC,   SINGULAR, BOOL,     router_preserve_hops,  14)
+X(a, STATIC,   SINGULAR, UINT32,   unknown_packet_threshold,  11)
 #define meshtastic_ModuleConfig_TrafficManagementConfig_CALLBACK NULL
 #define meshtastic_ModuleConfig_TrafficManagementConfig_DEFAULT NULL

@@ -1053,7 +1024,7 @@ extern const pb_msgdesc_t meshtastic_RemoteHardwarePin_msg;
 #define meshtastic_ModuleConfig_StoreForwardConfig_size 24
 #define meshtastic_ModuleConfig_TAKConfig_size   4
 #define meshtastic_ModuleConfig_TelemetryConfig_size 50
-#define meshtastic_ModuleConfig_TrafficManagementConfig_size 52
+#define meshtastic_ModuleConfig_TrafficManagementConfig_size 30
 #define meshtastic_ModuleConfig_size             227
 #define meshtastic_RemoteHardwarePin_size        21

@@ -99,7 +99,7 @@ static inline int get_max_num_nodes()
 #elif defined(ARCH_PORTDUINO)
 #define MAX_NUM_NODES 250 // native host: no flash/RAM constraint; match the ESP32-S3 top tier
 #else
-#define MAX_NUM_NODES 120 // nRF52840 (28 KB LittleFS) and generic ESP32
+#define MAX_NUM_NODES 120 // nRF52840 and generic ESP32 (inc. ESP32C3 etc.)
 #endif                    // platform
 #endif                    // MAX_NUM_NODES

@@ -109,10 +109,10 @@ static inline int get_max_num_nodes()
 /// flash-rich hosts get a cap >= their hot store (satellites for every node, as
 /// before the cap existed) while constrained parts stay at 40.
 #ifndef MAX_SATELLITE_NODES
-#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(ARCH_PORTDUINO)
+#if (defined(CONFIG_IDF_TARGET_ESP32S3) && defined(BOARD_HAS_PSRAM)) || defined(ARCH_PORTDUINO)
 #define MAX_SATELLITE_NODES 250
 #else
-#define MAX_SATELLITE_NODES 40 // nRF52840 (28 KB LittleFS) and generic ESP32
+#define MAX_SATELLITE_NODES 40 // nRF52840, generic ESP32, and ESP32-S3 without PSRAM
 #endif                         // platform
 #endif                         // MAX_SATELLITE_NODES

@@ -127,39 +127,62 @@ static inline int get_max_num_nodes()
 // architecture.h via configuration.h) isn't defined this early in every include
 // chain. Backed by the raw-flash ring below LittleFS — see WarmNodeStore.h.
 #define WARM_NODE_COUNT 200
-#elif defined(CONFIG_IDF_TARGET_ESP32S3)
-#define WARM_NODE_COUNT 2000 // PSRAM-backed when available; warm.dat ~80 KB
+#elif (defined(CONFIG_IDF_TARGET_ESP32S3) && defined(BOARD_HAS_PSRAM)) || defined(ARCH_PORTDUINO)
+#define WARM_NODE_COUNT 2000 // PSRAM-equipped ESP32-S3 / native host; warm cache in PSRAM (~80 KB)
+#elif defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32P4)
+#define WARM_NODE_COUNT 150 // 512 KB+ SRAM, no PSRAM (S3/C6/P4): ~6 KB heap (#10705)
+#elif defined(ARCH_ESP32)
+#define WARM_NODE_COUNT 100 // classic ESP32 (520 KB) / S2 (320 KB) / C3 (400 KB): tightest free heap w/ BLE+WiFi, ~4 KB (#10705)
+#elif defined(ARCH_RP2040)
+#define WARM_NODE_COUNT 150 // RP2040 (264 KB) / RP2350 (520 KB): bounded so warm.dat write fits the 8s watchdog (#10746)
 #else
-#define WARM_NODE_COUNT 320
-#endif // platform
-#endif // WARM_NODE_COUNT
+// nRF52840 is handled explicitly above (200, raw-flash ring). Any other nRF52 (non-XXAA) and any
+// future non-ESP32/non-RP LittleFS part fall through to this 320 default — flag for review if such a
+// RAM-constrained nRF52 target is ever added.
+#define WARM_NODE_COUNT 320 // other LittleFS-backed parts (e.g. non-nRF52840 nRF52)
+#endif                      // platform
+#endif                      // WARM_NODE_COUNT

 /// Max number of channels allowed
 #define MAX_NUM_CHANNELS (member_size(meshtastic_ChannelFile, channels) / member_size(meshtastic_ChannelFile, channels[0]))

 // Traffic Management module configuration
-// Enable per-variant by defining HAS_TRAFFIC_MANAGEMENT=1 in variant.h
-#ifndef HAS_TRAFFIC_MANAGEMENT
+// Enabled by default; STM32WL is excluded due to RAM constraints (MAX_NUM_NODES=10).
+// Disable per-variant by defining HAS_TRAFFIC_MANAGEMENT=0 in variant.h
+#ifdef ARCH_STM32WL
 #define HAS_TRAFFIC_MANAGEMENT 0
 #endif
+#ifndef HAS_TRAFFIC_MANAGEMENT
+#define HAS_TRAFFIC_MANAGEMENT 1
+#endif

 // HopScalingModule - variable hop module: dynamically adjusts broadcast hop_limit based on mesh density
 // Enable per-variant by defining HAS_VARIABLE_HOPS=1 in variant.h
 #ifdef ARCH_STM32WL
 #define HAS_VARIABLE_HOPS 0
 #endif
+
 #ifndef HAS_VARIABLE_HOPS
 #define HAS_VARIABLE_HOPS 1
 #endif

 // Cache size for traffic management (number of nodes to track)
-// Can be overridden per-variant based on available memory
+// Can be overridden per-variant by defining before this header is included.
 #ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#if HAS_TRAFFIC_MANAGEMENT
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 1000
-#else
+#if !HAS_TRAFFIC_MANAGEMENT
 #define TRAFFIC_MANAGEMENT_CACHE_SIZE 0
-#endif // HAS_TRAFFIC_MANAGEMENT
+#elif (defined(CONFIG_IDF_TARGET_ESP32S3) && defined(BOARD_HAS_PSRAM)) || defined(ARCH_PORTDUINO)
+#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048 // PSRAM-equipped ESP32-S3 / native host
+#elif defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32P4)
+#define TRAFFIC_MANAGEMENT_CACHE_SIZE 500 // 512 KB+ SRAM, no PSRAM (S3/C6/P4): ~5 KB heap (#10705)
+#elif defined(ARCH_ESP32)
+#define TRAFFIC_MANAGEMENT_CACHE_SIZE 400 // classic ESP32 / S2 / C3: tightest free heap, ~4 KB (#10705)
+#else
+// nRF52 (incl. nRF52840) and RP2040/RP2350 fall through here — there is no nRF/RP branch above,
+// by design. These parts have no ESP32-style WiFi+BLE coexistence eating the heap, so the larger
+// 1000-entry (~10 KB) cache fits: nRF52840 is BLE-only on 256 KB RAM; RP2040/RP2350 have 264/520 KB.
+#define TRAFFIC_MANAGEMENT_CACHE_SIZE 1000 // nRF52 / RP2040 / RP2350 / other non-ESP32
+#endif
 #endif // TRAFFIC_MANAGEMENT_CACHE_SIZE

 /// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
@@ -481,6 +481,8 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
                    screen->setFrames(graphics::Screen::FOCUS_PRESERVE); // <-- Rebuild screens
            } else if (mp.from == 0) { // local request from the phone — tell the user why it didn't take
                sendWarning(NodeDB::PROTECTED_CAP_WARN_FMT, "favorite", r->set_favorite_node, MAX_NUM_NODES - 2);
+            } else {
+                LOG_WARN("Remote set_favorite_node for 0x%x refused: protected-node cap", r->set_favorite_node);
            }
        }
        break;
@@ -508,6 +510,8 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
                saveChanges(SEGMENT_NODEDATABASE, false);
            } else if (mp.from == 0) { // local request from the phone — tell the user why it didn't take
                sendWarning(NodeDB::PROTECTED_CAP_WARN_FMT, "ignore", r->set_ignored_node, MAX_NUM_NODES - 2);
+            } else {
+                LOG_WARN("Remote set_ignored_node for 0x%x refused: protected-node cap", r->set_ignored_node);
            }
        }
        break;
@@ -128,8 +128,7 @@ void setupModules()
 #endif

 #if HAS_TRAFFIC_MANAGEMENT && !MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT
-    // Instantiate only when enabled to avoid extra memory use and background work.
-    if (moduleConfig.has_traffic_management && moduleConfig.traffic_management.enabled) {
+    if (moduleConfig.has_traffic_management) {
        trafficManagementModule = new TrafficManagementModule();
    }
 #endif
@@ -432,6 +432,42 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha

 #define RUNONCE_INTERVAL 5000;

+bool PositionModule::positionUnchangedSinceLastSend(const meshtastic_PositionLite &selfPos, bool useConfiguredPrecision)
+{
+    if (lastGpsLatitude == 0 && lastGpsLongitude == 0)
+        return false; // no prior broadcast to compare against
+
+    // Broadcast channel = the one sendOurPosition() would pick (first with non-zero on-wire
+    // precision). Default nodes gauge movement at that on-wire (public-clamped) resolution;
+    // trackers use their own configured (unclamped) precision so finer moves still count.
+    uint32_t precisionBits = 0;
+    for (uint8_t ch = 0; ch < 8; ch++) {
+        if (getPositionPrecisionForChannel(ch) == 0)
+            continue;
+        precisionBits =
+            useConfiguredPrecision ? getPositionPrecisionForChannel(channels.getByIndex(ch)) : getPositionPrecisionForChannel(ch);
+        break;
+    }
+
+    return positionWithinPrecisionCell(selfPos.latitude_i, selfPos.longitude_i, lastGpsLatitude, lastGpsLongitude, precisionBits);
+}
+
+bool PositionModule::positionWithinPrecisionCell(int32_t aLat, int32_t aLon, int32_t bLat, int32_t bLon, uint32_t precision)
+{
+    if (precision == 0 || precision >= 32)
+        return false; // sharing disabled or full precision: no coarse cell to hold within
+
+    return truncateCoordinate(aLat, precision) == truncateCoordinate(bLat, precision) &&
+           truncateCoordinate(aLon, precision) == truncateCoordinate(bLon, precision);
+}
+
+uint32_t PositionModule::effectiveBroadcastIntervalMs(uint32_t configuredIntervalMs, bool stationary, uint32_t stationaryFloorMs)
+{
+    if (stationary && stationaryFloorMs > configuredIntervalMs)
+        return stationaryFloorMs;
+    return configuredIntervalMs;
+}
+
 int32_t PositionModule::runOnce()
 {
    if (sleepOnNextExecution == true) {
@@ -458,7 +494,23 @@ int32_t PositionModule::runOnce()

    bool waitingForFreshPosition = (lastGpsSend == 0) && !config.position.fixed_position && !nodeDB->hasLocalPositionSinceBoot();

-    if (lastGpsSend == 0 || msSinceLastSend >= intervalMs) {
+    // Hold to the 12h floor when fixed_position (every role: pinning yourself forfeits the
+    // exception) or when stationary. A real move still goes out early via smart-broadcast below.
+    // Not-fixed exceptions: lost-and-found broadcasts freely; trackers judge movement at their
+    // own (unclamped) precision rather than the on-wire one (useConfiguredPrecision).
+    const auto role = config.device.role;
+    bool stationary = config.position.fixed_position;
+    if (!stationary && role != meshtastic_Config_DeviceConfig_Role_LOST_AND_FOUND && nodeDB->hasValidPosition(node)) {
+        const bool isTracker =
+            IS_ONE_OF(role, meshtastic_Config_DeviceConfig_Role_TRACKER, meshtastic_Config_DeviceConfig_Role_TAK_TRACKER);
+        meshtastic_PositionLite selfPos;
+        if (nodeDB->copyNodePosition(node->num, selfPos))
+            stationary = positionUnchangedSinceLastSend(selfPos, /*useConfiguredPrecision=*/isTracker);
+    }
+    uint32_t effectiveIntervalMs =
+        effectiveBroadcastIntervalMs(intervalMs, stationary, (uint32_t)default_position_stationary_broadcast_secs * 1000UL);
+
+    if (lastGpsSend == 0 || msSinceLastSend >= effectiveIntervalMs) {
        if (waitingForFreshPosition) {
 #ifdef GPS_DEBUG
            LOG_DEBUG("Skip initial position send; no fresh position since boot");
@@ -38,6 +38,14 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu

    void handleNewPosition();

+    // Pure broadcast-policy helpers, split out so they're unit-testable without the module.
+    // True when two coordinates truncate to the same precision cell (so a re-broadcast would be a
+    // duplicate). precision 0 or >=32 returns false: no coarse cell to hold within, never suppress.
+    static bool positionWithinPrecisionCell(int32_t aLat, int32_t aLon, int32_t bLat, int32_t bLon, uint32_t precision);
+    // Effective min interval: stationary positions are held to stationaryFloorMs (when that is the
+    // longer of the two); otherwise the normal configured interval.
+    static uint32_t effectiveBroadcastIntervalMs(uint32_t configuredIntervalMs, bool stationary, uint32_t stationaryFloorMs);
+
  protected:
    /** Called to handle a particular incoming message

@@ -57,6 +65,12 @@ class PositionModule : public ProtobufModule<meshtastic_Position>, private concu
  private:
    meshtastic_MeshPacket *allocPositionPacket();
    struct SmartPosition getDistanceTraveledSinceLastSend(meshtastic_PositionLite currentPosition);
+    // True when our position is unchanged since the last broadcast: it truncates to the same
+    // precision grid cell, so re-sending would be a duplicate that traffic management dedups
+    // downstream anyway. Used to hold stationary broadcasts to a 12h floor. useConfiguredPrecision
+    // gauges movement at our own configured (unclamped) precision rather than the on-wire
+    // (public-clamped) precision — trackers report finer movement.
+    bool positionUnchangedSinceLastSend(const meshtastic_PositionLite &selfPos, bool useConfiguredPrecision);
    meshtastic_MeshPacket *allocAtakPli();
    void trySetRtc(meshtastic_Position p, bool isLocal, bool forceUpdate = false);
    uint32_t precision;
@@ -8,6 +8,10 @@
 #include "meshUtils.h"
 #include <vector>

+#if HAS_TRAFFIC_MANAGEMENT
+#include "modules/TrafficManagementModule.h"
+#endif
+
 extern graphics::Screen *screen;

 TraceRouteModule *traceRouteModule;
@@ -323,6 +327,14 @@ void TraceRouteModule::maybeSetNextHop(NodeNum target, uint8_t nextHopByte)
        LOG_INFO("Updating next-hop for 0x%08x to 0x%02x based on traceroute", target, nextHopByte);
        node->next_hop = nextHopByte;
    }
+
+#if HAS_TRAFFIC_MANAGEMENT
+    // Mirror into the TMM overflow cache. Traceroute is the highest-confidence
+    // source (full known route), and this captures the target even when it isn't
+    // in the hot NodeDB — same rationale as the ACK-confirmed path in NextHopRouter.
+    if (trafficManagementModule)
+        trafficManagementModule->setNextHop(target, nextHopByte);
+#endif
 }

 void TraceRouteModule::processUpgradedPacket(const meshtastic_MeshPacket &mp)
@@ -20,9 +20,12 @@
 * - Router hop preservation (maintain hop_limit for router-to-router traffic)
 *
 * Memory Optimization:
- * Uses a unified cache with cuckoo hashing for O(1) lookups and 56% memory reduction
- * compared to separate per-feature caches. Timestamps are stored as 8-bit relative
- * offsets from a rolling epoch to further reduce memory footprint.
+ * Uses one flat unified cache (plain array, linear scan) shared by all
+ * per-node features instead of separate per-feature caches. Timestamps are
+ * stored as free-running modular tick counters (pos: 8-bit 360 s/tick;
+ * rate+unknown: paired 4-bit nibbles in one byte) for a 10-byte entry.
+ * LoRa packet rates are low enough that an O(n) scan of ~1000 entries is
+ * negligible next to packet processing.
 */
 class TrafficManagementModule : public MeshModule, private concurrency::OSThread
 {
@@ -38,6 +41,24 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
    void resetStats();
    void recordRouterHopPreserved();

+    // Next-hop overflow cache (routing hint).
+    // setNextHop: store a confirmed last-byte next hop for `dest`. Called by
+    //   NextHopRouter from its ACK-confirmed decision (see sniffReceived). The
+    //   byte must come from a bidirectionally-verified relay, not one-way inference.
+    // getNextHopHint: return the cached next-hop byte for `dest`, 0 if unknown.
+    // clearNextHop: forget any cached next hop for `dest` (setNextHop refuses to store
+    //   0, so this is the way NextHopRouter decays a stale/failing overflow route).
+    void setNextHop(NodeNum dest, uint8_t nextHopByte);
+    uint8_t getNextHopHint(NodeNum dest);
+    void clearNextHop(NodeNum dest);
+
+    // Warm-start the next-hop cache from persisted NodeInfoLite hints so confirmed
+    // hops survive later hot-store (NodeDB) eviction. Idempotent; runs once after
+    // nodeDB is populated (lazily on first maintenance pass).
+    // @return true if it actually ran (prereqs met / nothing to do); false if
+    //   prerequisites (cache, nodeDB) weren't ready yet, so the caller should retry.
+    bool preloadNextHopsFromNodeDB();
+
    /**
     * Check if this packet should have its hops exhausted.
     * Called from perhapsRebroadcast() to force hop_limit = 0 regardless of
@@ -48,182 +69,126 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
        return exhaustRequested && exhaustRequestedFrom == getFrom(&mp) && exhaustRequestedId == mp.id;
    }

+    // Injectable monotonic clock (ms). All TMM time reads go through clockMs() so unit tests can
+    // advance a virtual timebase instead of sleeping real seconds across the 6 min/360 s tick.
+    // Mirrors HopScalingModule::s_testNowMs. Writable from tests as TrafficManagementModule::s_testNowMs;
+    // ignored in production (clockMs() returns millis()).
+    inline static uint32_t s_testNowMs = 0;
+#ifdef PIO_UNIT_TESTING
+    static uint32_t clockMs() { return s_testNowMs; }
+#else
+    static uint32_t clockMs() { return millis(); }
+#endif
+
  protected:
    ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
    bool wantPacket(const meshtastic_MeshPacket *p) override { return true; }
    void alterReceived(meshtastic_MeshPacket &mp) override;
    int32_t runOnce() override;
-    // Protected so test shims can force epoch rollover behavior.
-    void resetEpoch(uint32_t nowMs);
+    // Protected so test shims can flush per-node traffic state.
+    void flushCache();
+    // Introspection for tests: the cached device role for a node, or -1 if the node has
+    // no cache entry (distinguishes "not tracked / evicted" from CLIENT == 0).
+    int peekCachedRole(NodeNum node);

  private:
    // =========================================================================
    // Unified Cache Entry (10 bytes) - Same for ALL platforms
    // =========================================================================
    //
-    // A single compact structure used across ESP32, NRF52, and all other platforms.
-    // Memory: 10 bytes × 2048 entries = 20KB
-    //
-    // Position Fingerprinting:
-    //   Instead of storing full coordinates (8 bytes) or a computed hash,
-    //   we store an 8-bit fingerprint derived deterministically from the
-    //   truncated lat/lon. This extracts the lower 4 significant bits from
-    //   each coordinate: fingerprint = (lat_low4 << 4) | lon_low4
-    //
-    //   Benefits over hash:
-    //   - Adjacent grid cells have sequential fingerprints (no collision)
-    //   - Two positions only collide if 16+ grid cells apart in BOTH dimensions
-    //   - Deterministic: same input always produces same output
-    //
-    // Adaptive Timestamp Resolution:
-    //   All timestamps use 8-bit values with adaptive resolution calculated
-    //   from config at startup. Resolution = max(60, min(339, interval/2)).
-    //   - Min 60 seconds ensures reasonable precision
-    //   - Max 339 seconds allows ~24 hour range (255 * 339 = 86445 sec)
-    //   - interval/2 ensures at least 2 ticks per configured interval
-    //
    // Layout:
-    //   [0-3]   node            - NodeNum (4 bytes)
-    //   [4]     pos_fingerprint - 4 bits lat + 4 bits lon (1 byte)
-    //   [5]     rate_count      - Packets in current window (1 byte)
-    //   [6]     unknown_count   - Unknown packets count (1 byte)
-    //   [7]     pos_time        - Position timestamp (1 byte, adaptive resolution)
-    //   [8]     rate_time       - Rate window start (1 byte, adaptive resolution)
-    //   [9]     unknown_time    - Unknown tracking start (1 byte, adaptive resolution)
+    //   [0-3]   node               - NodeNum (4 bytes, 0 = empty slot)
+    //   [4]     pos_fingerprint    - 4 bits lat + 4 bits lon (0 = no position seen)
+    //   [5]     rate_count         - [7:6] role[3:2] | [5:0] packets in rate window (0 = no window active)
+    //   [6]     unknown_count      - [7:6] role[1:0] | [5:0] unknown packets in window (0 = no window active)
+    //   [7]     pos_time           - Position tick (uint8, free-running 360 s/tick)
+    //   [8]     rate_unknown_time  - [7:4] rate nibble (300 s/tick) | [3:0] unknown nibble (60 s/tick)
+    //   [9]     next_hop           - Last-byte relay to reach `node` (0 = none)
    //
+    // The 4-bit device role (bits [7:6] of rate_count paired with [7:6] of unknown_count)
+    // caches the sender's meshtastic_Config_DeviceConfig_Role as a third fallback after the
+    // hot store and warm store, for nodes evicted from both. Read/written via
+    // resolveSenderRole(). Max encodable value is 15.
+    //
+    // Presence sentinels (no epoch, no +1 offset needed):
+    //   pos active:     pos_fingerprint != 0
+    //   rate active:    getRateCount() != 0     (low 6 bits only)
+    //   unknown active: getUnknownCount() != 0  (low 6 bits only)
+    //
+    // next_hop: routing hint written only from ACK-confirmed NextHopRouter decisions.
+    // No TTL — keeps the slot alive across maintenance sweeps.
+    //
+#if _meshtastic_Config_DeviceConfig_Role_MAX > 15
+#warning "Device role enum max exceeds 15 — TMM 4-bit role cache (rate_count[7:6]/unknown_count[7:6]) will truncate new values"
+#endif
    struct __attribute__((packed)) UnifiedCacheEntry {
-        NodeNum node;            // 4 bytes - Node identifier (0 = empty slot)
-        uint8_t pos_fingerprint; // 1 byte  - Lower 4 bits of lat + lon
-        uint8_t rate_count;      // 1 byte  - Packet count (saturates at 255)
-        uint8_t unknown_count;   // 1 byte  - Unknown packet count (saturates at 255)
-        uint8_t pos_time;        // 1 byte  - Position timestamp (adaptive resolution)
-        uint8_t rate_time;       // 1 byte  - Rate window start (adaptive resolution)
-        uint8_t unknown_time;    // 1 byte  - Unknown tracking start (adaptive resolution)
+        NodeNum node;
+        uint8_t pos_fingerprint;
+        uint8_t rate_count;    // [7:6] = role[3:2], [5:0] = count (max 63)
+        uint8_t unknown_count; // [7:6] = role[1:0], [5:0] = count (max 63)
+        uint8_t pos_time;
+        uint8_t rate_unknown_time;
+        uint8_t next_hop;
+
+        uint8_t getRateCount() const { return rate_count & 0x3F; }
+        void setRateCount(uint8_t c) { rate_count = static_cast<uint8_t>((rate_count & 0xC0) | (c & 0x3F)); }
+        uint8_t getUnknownCount() const { return unknown_count & 0x3F; }
+        void setUnknownCount(uint8_t c) { unknown_count = static_cast<uint8_t>((unknown_count & 0xC0) | (c & 0x3F)); }
+        uint8_t getCachedRole() const { return static_cast<uint8_t>(((rate_count >> 6) << 2) | (unknown_count >> 6)); }
+        void setCachedRole(uint8_t role)
+        {
+            rate_count = static_cast<uint8_t>((rate_count & 0x3F) | ((role >> 2) << 6));
+            unknown_count = static_cast<uint8_t>((unknown_count & 0x3F) | ((role & 0x03) << 6));
+        }
+        uint8_t getRateTime() const { return (rate_unknown_time >> 4) & 0x0F; }
+        uint8_t getUnknownTime() const { return rate_unknown_time & 0x0F; }
+        void setRateTime(uint8_t t) { rate_unknown_time = static_cast<uint8_t>((rate_unknown_time & 0x0F) | ((t & 0x0F) << 4)); }
+        void setUnknownTime(uint8_t t) { rate_unknown_time = static_cast<uint8_t>((rate_unknown_time & 0xF0) | (t & 0x0F)); }
    };
    static_assert(sizeof(UnifiedCacheEntry) == 10, "UnifiedCacheEntry should be 10 bytes");

    // =========================================================================
-    // Cuckoo Hash Table Implementation
+    // Flat unified cache
    // =========================================================================
    //
-    // Cuckoo hashing provides O(1) worst-case lookup time using two hash functions.
-    // Each key can be in one of two possible locations (h1 or h2). On collision,
-    // the existing entry is "kicked" to its alternate location.
+    // Plain array, linear scan (same idiom as WarmNodeStore). A lookup walks at
+    // most cacheSize() × 10 B — microseconds at LoRa packet rates, not worth a
+    // hash table. Insertion on a full cache evicts the stalest entry,
+    // preferring entries without a next_hop hint (those are the long-tail
+    // routing state this cache exists to keep).
    //
-    // Benefits over linear scan:
-    // - O(1) lookup vs O(n) - critical at packet processing rates
-    // - O(1) insertion (amortized) with simple eviction on cycles
-    // - ~95% load factor achievable
-    //
-    // Cache size rounds to power-of-2 for fast modulo via bitmask.
-    // TRAFFIC_MANAGEMENT_CACHE_SIZE=2000 → cacheSize()=2048
-    //
-    static constexpr uint16_t cacheSize();
-    static constexpr uint16_t cacheMask();
+    static constexpr uint16_t cacheSize() { return TRAFFIC_MANAGEMENT_CACHE_SIZE; }

-    // Hash functions for cuckoo hashing
-    inline uint16_t cuckooHash1(NodeNum node) const { return node & cacheMask(); }
-    inline uint16_t cuckooHash2(NodeNum node) const { return ((node * 2654435769u) >> (32 - cuckooHashBits())) & cacheMask(); }
-    static constexpr uint8_t cuckooHashBits();
-
-    // NodeInfo cache configuration (PSRAM path):
-    // - Payload lives in PSRAM
-    // - DRAM keeps packed 12-bit tags with 4-way bucketed cuckoo hashing
-    //   (Fan et al., CoNEXT 2014). Tag value 0 is reserved as "empty".
-    static constexpr uint16_t kNodeInfoIndexMetadataBudgetBytes = 3072; // 3KB DRAM tag store
-    static constexpr uint8_t kNodeInfoTargetOccupancyPercent = 95;
-    static constexpr uint8_t kNodeInfoBucketSize = 4;
-    static constexpr uint8_t kNodeInfoTagBits = 12;
-    static constexpr uint16_t kNodeInfoTagMask = static_cast<uint16_t>((1u << kNodeInfoTagBits) - 1u);
-    static constexpr uint16_t kNodeInfoIndexSlotsRaw =
-        static_cast<uint16_t>((kNodeInfoIndexMetadataBudgetBytes * 8u) / kNodeInfoTagBits);
-    static constexpr uint16_t kNodeInfoIndexSlots =
-        static_cast<uint16_t>(kNodeInfoIndexSlotsRaw - (kNodeInfoIndexSlotsRaw % kNodeInfoBucketSize));
-    static constexpr uint16_t kNodeInfoTargetEntries =
-        static_cast<uint16_t>((kNodeInfoIndexSlots * kNodeInfoTargetOccupancyPercent) / 100u);
-    static_assert((kNodeInfoIndexSlots % kNodeInfoBucketSize) == 0, "NodeInfo slot count must align to bucket size");
-    static_assert(kNodeInfoTargetEntries < (1u << kNodeInfoTagBits), "NodeInfo tag bits must encode payload index");
-
-    static constexpr uint16_t nodeInfoTargetEntries();
-    static constexpr uint16_t nodeInfoIndexMetadataBudgetBytes();
-    static constexpr uint8_t nodeInfoTargetOccupancyPercent();
-    static constexpr uint8_t nodeInfoBucketSize();
-    static constexpr uint8_t nodeInfoTagBits();
-    static constexpr uint16_t nodeInfoTagMask();
-    static constexpr uint16_t nodeInfoIndexSlots();
-    static constexpr uint16_t nodeInfoBucketCount();
-    static constexpr uint16_t nodeInfoBucketMask();
-    static constexpr uint8_t nodeInfoBucketHashBits();
-    inline uint16_t nodeInfoHash1(NodeNum node) const { return node & nodeInfoBucketMask(); }
-    inline uint16_t nodeInfoHash2(NodeNum node) const
-    {
-        return ((node * 2246822519u) >> (32 - nodeInfoBucketHashBits())) & nodeInfoBucketMask();
-    }
+    // NodeInfo cache configuration (PSRAM path): a flat PSRAM array of payload
+    // entries, linear scan keyed by `node`, LRU eviction by lastObservedMs.
+    // NodeInfo traffic is low-rate, so a full scan per lookup/insert is fine.
+    static constexpr uint16_t kNodeInfoCacheEntries = 2000;
+    static constexpr uint16_t nodeInfoTargetEntries() { return kNodeInfoCacheEntries; }

    // =========================================================================
-    // Adaptive Timestamp Resolution
+    // Free-Running Tick Counters
    // =========================================================================
    //
-    // All timestamps use 8-bit values with adaptive resolution calculated from
-    // config at startup. This allows ~24 hour range while maintaining precision.
+    // Timestamps are stored as free-running modular tick counters derived from
+    // millis(). No epoch anchor needed: modular subtraction gives correct age
+    // as long as the true age stays below the counter period.
    //
-    // Resolution formula: max(60, min(339, interval/2))
-    //   - 60 sec minimum ensures reasonable precision
-    //   - 339 sec maximum allows 24 hour range (255 * 339 ≈ 86400 sec)
-    //   - interval/2 ensures at least 2 ticks per configured interval
+    //   pos_time  : uint8  (256 ticks × 360 s = 25.6 h period; max window 12 h = 120 ticks)
+    //   rate_time : nibble (16 ticks × 300 s = 80 min period; max window 1 h = 12 ticks)
+    //   unknown_time: nibble (16 ticks × 60 s = 16 min period; max window 12 min = 12 ticks)
    //
-    // Since config changes require reboot, resolution is calculated once.
+    // Presence sentinels (no +1 offset needed; count fields serve as guards):
+    //   pos active:     pos_fingerprint != 0  (0 is reserved sentinel; computePositionFingerprint() remaps computed-0 → 0xFF)
+    //   rate active:    getRateCount() != 0   (low 6 bits; high 2 bits are cached role)
+    //   unknown active: getUnknownCount() != 0
    //
-    uint32_t cacheEpochMs = 0;
-    uint16_t posTimeResolution = 60;     // Seconds per tick for position
-    uint16_t rateTimeResolution = 60;    // Seconds per tick for rate limiting
-    uint16_t unknownTimeResolution = 60; // Seconds per tick for unknown tracking
+    static constexpr uint32_t kPosTimeTickMs = 360'000UL;    // 6 min/tick
+    static constexpr uint32_t kRateTimeTickMs = 300'000UL;   // 5 min/tick
+    static constexpr uint32_t kUnknownTimeTickMs = 60'000UL; // 1 min/tick

-    // Calculate resolution from configured interval (called once at startup)
-    static uint16_t calcTimeResolution(uint32_t intervalSecs)
-    {
-        // Resolution = interval/2 to ensure at least 2 ticks per interval
-        // Clamped to [60, 339] for min precision and max 24h range
-        uint32_t res = (intervalSecs > 0) ? (intervalSecs / 2) : 60;
-        if (res < 60)
-            res = 60;
-        if (res > 339)
-            res = 339;
-        return static_cast<uint16_t>(res);
-    }
-
-    // Convert to/from 8-bit relative timestamps with given resolution
-    uint8_t toRelativeTime(uint32_t nowMs, uint16_t resolutionSecs) const
-    {
-        uint32_t ticks = (nowMs - cacheEpochMs) / (resolutionSecs * 1000UL);
-        return (ticks > UINT8_MAX) ? UINT8_MAX : static_cast<uint8_t>(ticks);
-    }
-    uint32_t fromRelativeTime(uint8_t ticks, uint16_t resolutionSecs) const
-    {
-        return cacheEpochMs + (static_cast<uint32_t>(ticks) * resolutionSecs * 1000UL);
-    }
-
-    // Convenience wrappers for each timestamp type
-    uint8_t toRelativePosTime(uint32_t nowMs) const { return toRelativeTime(nowMs, posTimeResolution); }
-    uint32_t fromRelativePosTime(uint8_t t) const { return fromRelativeTime(t, posTimeResolution); }
-
-    uint8_t toRelativeRateTime(uint32_t nowMs) const { return toRelativeTime(nowMs, rateTimeResolution); }
-    uint32_t fromRelativeRateTime(uint8_t t) const { return fromRelativeTime(t, rateTimeResolution); }
-
-    uint8_t toRelativeUnknownTime(uint32_t nowMs) const { return toRelativeTime(nowMs, unknownTimeResolution); }
-    uint32_t fromRelativeUnknownTime(uint8_t t) const { return fromRelativeTime(t, unknownTimeResolution); }
-
-    // Epoch reset when any timestamp approaches overflow
-    // With max resolution of 339 sec, 200 ticks = ~19 hours (safe margin for 24h max)
-    bool needsEpochReset(uint32_t nowMs) const
-    {
-        uint16_t maxRes = posTimeResolution;
-        if (rateTimeResolution > maxRes)
-            maxRes = rateTimeResolution;
-        if (unknownTimeResolution > maxRes)
-            maxRes = unknownTimeResolution;
-        return (nowMs - cacheEpochMs) > (200UL * maxRes * 1000UL);
-    }
+    static uint8_t currentPosTick() { return static_cast<uint8_t>(clockMs() / kPosTimeTickMs); }
+    static uint8_t currentRateTick() { return static_cast<uint8_t>((clockMs() / kRateTimeTickMs) & 0x0F); }
+    static uint8_t currentUnknownTick() { return static_cast<uint8_t>((clockMs() / kUnknownTimeTickMs) & 0x0F); }
    // =========================================================================
    // Position Fingerprint
    // =========================================================================
@@ -246,7 +211,7 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
    // =========================================================================

    mutable concurrency::Lock cacheLock; // Protects all cache access
-    UnifiedCacheEntry *cache = nullptr;  // Cuckoo hash table (unified for all platforms)
+    UnifiedCacheEntry *cache = nullptr;  // Flat unified cache (linear scan; all platforms)
    bool cacheFromPsram = false;         // Tracks allocator for correct deallocation

    struct NodeInfoPayloadEntry {
@@ -278,11 +243,8 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
        uint8_t decodedBitfield;
    };

-    NodeInfoPayloadEntry *nodeInfoPayload = nullptr; // NodeInfo payloads in PSRAM
+    NodeInfoPayloadEntry *nodeInfoPayload = nullptr; // NodeInfo payloads in PSRAM (flat array, linear scan)
    bool nodeInfoPayloadFromPsram = false;           // Tracks allocator for correct deallocation
-    uint8_t *nodeInfoIndex = nullptr;                // Packed 12-bit NodeInfo tags in DRAM
-    uint16_t nodeInfoAllocHint = 0;
-    uint16_t nodeInfoEvictCursor = 0;

    meshtastic_TrafficManagementStats stats;

@@ -293,29 +255,37 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
    NodeNum exhaustRequestedFrom = 0;
    PacketId exhaustRequestedId = 0;

+    // One-shot guard: warm-start next-hop cache from NodeDB on first maintenance pass.
+    bool nextHopPreloaded = false;
+
    // =========================================================================
    // Cache Operations
    // =========================================================================

-    // Find or create entry for node using cuckoo hashing
-    // Returns nullptr if cache is full and eviction fails
+    // Find or create entry for node (linear scan; stalest-first eviction when full)
    UnifiedCacheEntry *findOrCreateEntry(NodeNum node, bool *isNew);

    // Find existing entry (no creation)
    UnifiedCacheEntry *findEntry(NodeNum node);

-    // NodeInfo cache operations (bucketed cuckoo index + PSRAM payloads)
+    // Resolve a sender's advertised device role for the position hot path. The tier-3
+    // cache (this entry's getCachedRole) is authoritative and is kept fresh by
+    // updateCachedRoleFromNodeInfo() — updated when NodeDB learns a role, not re-derived
+    // per packet. Only on first tracking (isNew) do we scan NodeDB (hot store → warm
+    // store, via getNodeRole) to seed the cache, so a resident special-role node is
+    // correct from its first position; after that the read is O(1) and survives the node
+    // aging out of both NodeDB stores. Caller must hold cacheLock; entry may be null
+    // (→ NodeDB scan only).
+    meshtastic_Config_DeviceConfig_Role resolveSenderRole(NodeNum from, UnifiedCacheEntry *entry, bool isNew);
+
+    // Refresh the tier-3 role cache from an observed NodeInfo (the same event that updates
+    // NodeDB's role). Reads role from the packet's User payload; updates only nodes already
+    // tracked (no entry creation). Takes cacheLock.
+    void updateCachedRoleFromNodeInfo(const meshtastic_MeshPacket &mp);
+
+    // NodeInfo cache operations (flat PSRAM payload array, linear scan)
    const NodeInfoPayloadEntry *findNodeInfoEntry(NodeNum node) const;
    NodeInfoPayloadEntry *findOrCreateNodeInfoEntry(NodeNum node, bool *usedEmptySlot);
-    uint16_t findNodeInfoPayloadIndex(NodeNum node) const;
-    bool removeNodeInfoIndexEntry(NodeNum node, uint16_t payloadIndex);
-    uint16_t allocateNodeInfoPayloadSlot();
-    uint16_t evictNodeInfoPayloadSlot();
-    bool tryInsertNodeInfoEntryInBucket(uint16_t bucket, uint16_t tag);
-    uint16_t encodeNodeInfoTag(uint16_t payloadIndex) const;
-    uint16_t decodeNodeInfoPayloadIndex(uint16_t tag) const;
-    uint16_t getNodeInfoTag(uint16_t slot) const;
-    void setNodeInfoTag(uint16_t slot, uint16_t tag);
    uint16_t countNodeInfoEntriesLocked() const;
    void cacheNodeInfoPacket(const meshtastic_MeshPacket &mp);

@@ -333,101 +303,7 @@ class TrafficManagementModule : public MeshModule, private concurrency::OSThread
    void incrementStat(uint32_t *field);
 };

-// =========================================================================
-// Compile-time Cache Size Calculations
-// =========================================================================
-//
-// Round TRAFFIC_MANAGEMENT_CACHE_SIZE up to next power of 2 for efficient
-// cuckoo hash indexing (allows bitmask instead of modulo).
-//
-// These use C++11-compatible constexpr (single return statement).
-//
-
-namespace detail
-{
-// Helper: round up to next power of 2 using bit manipulation
-constexpr uint16_t nextPow2(uint16_t n)
-{
-    return n == 0 ? 0 : (((n - 1) | ((n - 1) >> 1) | ((n - 1) >> 2) | ((n - 1) >> 4) | ((n - 1) >> 8)) + 1);
-}
-
-// Helper: floor(log2(n)) for n >= 0, C++11-compatible constexpr.
-constexpr uint8_t log2Floor(uint16_t n)
-{
-    return n <= 1 ? 0 : static_cast<uint8_t>(1 + log2Floor(static_cast<uint16_t>(n >> 1)));
-}
-
-// Helper: ceil(log2(n)) for n >= 1, C++11-compatible constexpr.
-constexpr uint8_t log2Ceil(uint16_t n)
-{
-    return n <= 1 ? 0 : static_cast<uint8_t>(1 + log2Floor(static_cast<uint16_t>(n - 1)));
-}
-} // namespace detail
-
-constexpr uint16_t TrafficManagementModule::cacheSize()
-{
-    return detail::nextPow2(TRAFFIC_MANAGEMENT_CACHE_SIZE);
-}
-
-constexpr uint16_t TrafficManagementModule::cacheMask()
-{
-    return cacheSize() > 0 ? cacheSize() - 1 : 0;
-}
-
-constexpr uint8_t TrafficManagementModule::cuckooHashBits()
-{
-    return detail::log2Floor(cacheSize());
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoTargetEntries()
-{
-    return kNodeInfoTargetEntries;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoIndexMetadataBudgetBytes()
-{
-    return kNodeInfoIndexMetadataBudgetBytes;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoTargetOccupancyPercent()
-{
-    return kNodeInfoTargetOccupancyPercent;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoBucketSize()
-{
-    return kNodeInfoBucketSize;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoTagBits()
-{
-    return kNodeInfoTagBits;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoTagMask()
-{
-    return kNodeInfoTagMask;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoIndexSlots()
-{
-    return kNodeInfoIndexSlots;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoBucketCount()
-{
-    return static_cast<uint16_t>(nodeInfoIndexSlots() / nodeInfoBucketSize());
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoBucketMask()
-{
-    return nodeInfoBucketCount() > 0 ? nodeInfoBucketCount() - 1 : 0;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoBucketHashBits()
-{
-    return detail::log2Floor(nodeInfoBucketCount());
-}
+static_assert(TRAFFIC_MANAGEMENT_CACHE_SIZE <= UINT16_MAX, "cacheSize() returns uint16_t");

 extern TrafficManagementModule *trafficManagementModule;

@@ -21,7 +21,12 @@
 #include "PowerStatus.h"

 #include "host/ble_gap.h"
+#include "host/ble_hs.h"
 #include "host/ble_store.h"
+#ifdef ARCH_ESP32
+#include <nvs.h>
+#include <nvs_flash.h>
+#endif

 namespace
 {
@@ -30,6 +35,56 @@ constexpr uint16_t kPreferredBleTxOctets = 251;
 constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 } // namespace

+#ifdef ARCH_ESP32
+// Discard NimBLE bonds left in an incompatible on-disk format. The ESP-IDF/NimBLE upgrade changed
+// the length of the fixed-size bond records (ble_store_value_sec), so the new host rejects every
+// old record on each boot ("NVS data size mismatch for obj_type 1 ...") with no auto-recovery --
+// pairing stays broken until a factory reset. Wipe the bond namespace once when a stored record's
+// size differs from this build's struct; a same-size store is left untouched, so this never loops.
+// Adapted from https://github.com/h2zero/NimBLE-Arduino/issues/740
+static void purgeIncompatibleBleBonds()
+{
+    esp_err_t initErr = nvs_flash_init();
+    if (initErr != ESP_OK) {
+        LOG_WARN("purgeIncompatibleBleBonds: nvs_flash_init failed, err=%d", (int)initErr);
+        return; // NVS should already be up; if not, nothing safe to do here
+    }
+
+    nvs_handle_t handle = 0;
+    esp_err_t err = nvs_open("nimble_bond", NVS_READWRITE, &handle);
+    if (err == ESP_ERR_NVS_NOT_FOUND) {
+        return; // no bonds stored yet
+    }
+    if (err != ESP_OK) {
+        LOG_ERROR("nimble_bond open failed, err=%d", err);
+        return;
+    }
+
+    // Probe the first record of each fixed-size object type (bonds are written from index 1); a
+    // stored size differing from this build's struct means the store predates a format change.
+    size_t sz = 0;
+    bool mismatch = (nvs_get_blob(handle, "our_sec_1", nullptr, &sz) == ESP_OK && sz != sizeof(struct ble_store_value_sec)) ||
+                    (nvs_get_blob(handle, "peer_sec_1", nullptr, &sz) == ESP_OK && sz != sizeof(struct ble_store_value_sec)) ||
+                    (nvs_get_blob(handle, "cccd_sec_1", nullptr, &sz) == ESP_OK && sz != sizeof(struct ble_store_value_cccd));
+
+    bool wiped = false;
+    if (mismatch) {
+        LOG_WARN("Wiping incompatible NimBLE bonds (on-disk format changed)");
+        wiped = nvs_erase_all(handle) == ESP_OK && nvs_commit(handle) == ESP_OK;
+        if (!wiped) {
+            LOG_ERROR("Failed to erase nimble_bond namespace");
+        }
+    }
+
+    nvs_close(handle);
+
+    if (wiped) {
+        LOG_INFO("Restarting after NimBLE bond cleanup");
+        ESP.restart();
+    }
+}
+#endif
+
 // Debugging options: careful, they slow things down quite a bit!
 // #define DEBUG_NIMBLE_ON_READ_TIMING  // uncomment to time onRead duration
 // #define DEBUG_NIMBLE_ON_WRITE_TIMING // uncomment to time onWrite duration
@@ -47,6 +102,11 @@ BLEServer *bleServer;
 static bool passkeyShowing;
 static std::atomic<uint16_t> nimbleBluetoothConnHandle{BLE_HS_CONN_HANDLE_NONE}; // BLE_HS_CONN_HANDLE_NONE means "no connection"

+// Set by onDisconnect to defer (re)starting advertising to the main task. A stale-bond reconnect
+// triggers a MIC failure + NimBLE host reset; re-entering ble_gap_adv_* from the disconnect
+// callback while the host is mid-reset crashes (LoadProhibited), so the main task does it instead.
+static std::atomic<bool> pendingStartAdvertising{false};
+
 static void clearPairingDisplay()
 {
    if (!passkeyShowing) {
@@ -155,6 +215,21 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
  protected:
    virtual int32_t runOnce() override
    {
+        // Service a deferred advertising restart from onDisconnect, gated on ble_hs_synced() so we
+        // never re-enter the GAP API while the host is still mid-reset.
+        if (pendingStartAdvertising) {
+            if (checkIsConnected()) {
+                pendingStartAdvertising = false; // a new physical connection beat us to it; nothing to do
+            } else if (ble_hs_synced()) {
+                pendingStartAdvertising = false;
+                if (nimbleBluetooth) {
+                    nimbleBluetooth->startAdvertising();
+                }
+            } else {
+                return 200; // host still re-syncing after a reset; retry shortly
+            }
+        }
+
        while (runOnceHasWorkToDo()) {
            /*
              PROCESS fromPhoneQueue BEFORE toPhoneQueue:
@@ -592,6 +667,14 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
    }
    void onAuthenticationComplete(ble_gap_conn_desc *desc) override
    {
+        // Called on every BLE_GAP_EVENT_ENC_CHANGE, success or failure. A stale-bond reconnect
+        // yields a *failed* encryption change here -- don't latch a connected/authenticated state
+        // on a link that is actually being torn down.
+        if (desc == nullptr || !desc->sec_state.encrypted) {
+            LOG_WARN("BLE encryption change without an encrypted link; ignoring");
+            return;
+        }
+
        LOG_INFO("BLE authentication complete");

        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
@@ -667,7 +750,13 @@ class NimbleBluetoothServerCallback : public BLEServerCallbacks

        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;

-        ble->startAdvertising();
+        // Defer the advertising restart to runOnce (see pendingStartAdvertising): calling
+        // startAdvertising() here would crash if this disconnect was a host reset.
+        pendingStartAdvertising = true;
+        if (bluetoothPhoneAPI) {
+            bluetoothPhoneAPI->setIntervalFromNow(0);
+        }
+        concurrency::mainDelay.interrupt(); // wake the main loop to service the restart
    }
 };

@@ -761,6 +850,12 @@ void NimbleBluetooth::setup()

    LOG_INFO("Init the NimBLE bluetooth module");

+#ifdef ARCH_ESP32
+    // Runs before BLEDevice::init() reads the bond store, but logs after the "Init" line above so
+    // any bond-cleanup output doesn't appear to precede the module init.
+    purgeIncompatibleBleBonds(); // wipe bonds left in an incompatible on-disk format (post-upgrade)
+#endif
+
    BLEDevice::init(getDeviceName());
    BLEDevice::setPower(ESP_PWR_LVL_P9);

@@ -889,6 +984,7 @@ void updateBatteryLevel(uint8_t level)
 void NimbleBluetooth::clearBonds()
 {
    LOG_INFO("Clearing bluetooth bonds!");
+    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_OUR_SEC, nullptr);
    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
 }
@@ -901,13 +997,4 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
    logRadioCharacteristic->setValue(logMessage, length);
    logRadioCharacteristic->notify();
 }
-
-void clearNVS()
-{
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
-#ifdef ARCH_ESP32
-    ESP.restart();
-#endif
-}
 #endif
@@ -15,6 +15,7 @@
 #endif

 #include "esp_mac.h"
+#include "freertosinc.h"
 #include "meshUtils.h"
 #include "sleep.h"
 #include "soc/rtc.h"
@@ -276,6 +277,8 @@ void cpuDeepSleep(uint32_t msecToWake)
    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
 #endif

-    esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
-    esp_deep_sleep_start();                              // TBD mA sleep current (battery)
+    // User shutdown (DELAY_FOREVER / portMAX_DELAY): no RTC timer — align with nRF52 system_off semantics.
+    if (msecToWake != portMAX_DELAY)
+        esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
+    esp_deep_sleep_start();
 }
@@ -598,7 +598,8 @@ void portduinoSetup()
    for (const auto *i : portduino_config.all_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i->config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i->config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i->enabled) {
@@ -617,7 +618,8 @@ void portduinoSetup()
    for (auto i : portduino_config.extra_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i.config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i.enabled) {
@@ -664,7 +666,8 @@ void portduinoSetup()
    for (auto i : portduino_config.extra_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i.config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i.enabled && i.default_high) {
@@ -674,7 +677,8 @@ void portduinoSetup()
    }

    // Only initialize the radio pins when dealing with real, kernel controlled SPI hardware
-    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341") {
+    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341" &&
+        portduino_config.lora_spi_dev != "serial") {
        SPI.begin(portduino_config.lora_spi_dev.c_str());
    }

@@ -708,6 +712,7 @@ void portduinoSetup()
    }
    if (portduino_config.lora_spi_dev != "") {
        portduinoSetOptions({.realHardware = true});
+        LOG_DEBUG("Running with real hardware SPI device %s", portduino_config.lora_spi_dev.c_str());
    }
    return;
 }
@@ -844,12 +849,15 @@ bool loadConfig(const char *configPath)
            }

            portduino_config.spiSpeed = yamlConfig["Lora"]["spiSpeed"].as<int>(2000000);
+            portduino_config.lora_serial_device = yamlConfig["Lora"]["SerialDevice"].as<std::string>("");
+            portduino_config.lora_serial_baud = yamlConfig["Lora"]["SerialBaud"].as<int>(115200);
+            portduino_config.lora_serial_timeout_ms = yamlConfig["Lora"]["SerialTimeoutMs"].as<int>(500);
            portduino_config.lora_usb_serial_num = yamlConfig["Lora"]["USB_Serialnum"].as<std::string>("");
            portduino_config.lora_usb_pid = yamlConfig["Lora"]["USB_PID"].as<int>(0x5512);
            portduino_config.lora_usb_vid = yamlConfig["Lora"]["USB_VID"].as<int>(0x1A86);

            portduino_config.lora_spi_dev = yamlConfig["Lora"]["spidev"].as<std::string>("spidev0.0");
-            if (portduino_config.lora_spi_dev != "ch341") {
+            if (portduino_config.lora_spi_dev != "ch341" && portduino_config.lora_spi_dev != "serial") {
                portduino_config.lora_spi_dev = "/dev/" + portduino_config.lora_spi_dev;
                if (portduino_config.lora_spi_dev.length() == 14) {
                    int x = portduino_config.lora_spi_dev.at(11) - '0';
@@ -86,6 +86,9 @@ extern struct portduino_config_struct {
    bool has_device_id = false;
    uint8_t device_id[16] = {0};
    std::string lora_spi_dev = "";
+    std::string lora_serial_device = "";
+    int lora_serial_baud = 115200;
+    int lora_serial_timeout_ms = 500;
    std::string lora_usb_serial_num = "";
    int lora_spi_dev_int = 0;
    int lora_default_gpiochip = 0;
@@ -276,6 +279,12 @@ extern struct portduino_config_struct {
        }
        if (lora_usb_serial_num != "")
            out << YAML::Key << "USB_Serialnum" << YAML::Value << lora_usb_serial_num;
+        if (lora_serial_device != "")
+            out << YAML::Key << "SerialDevice" << YAML::Value << lora_serial_device;
+        if (lora_serial_baud != 115200)
+            out << YAML::Key << "SerialBaud" << YAML::Value << lora_serial_baud;
+        if (lora_serial_timeout_ms != 500)
+            out << YAML::Key << "SerialTimeoutMs" << YAML::Value << lora_serial_timeout_ms;
        if (spiSpeed != 2000000)
            out << YAML::Key << "spiSpeed" << YAML::Value << spiSpeed;
        if (rfswitch_dio_pins[0] != RADIOLIB_NC) {
@@ -0,0 +1,595 @@
+#include "platform/portduino/SerialHal.h"
+
+#include "mesh/mesh-pb-constants.h"
+#include "platform/portduino/PortduinoGlue.h"
+#include <cerrno>
+#include <chrono>
+#include <cstring>
+#include <fcntl.h>
+#include <poll.h>
+#include <sched.h>
+#include <sys/time.h>
+#include <termios.h>
+#include <unistd.h>
+#include <utility>
+
+namespace
+{
+constexpr uint8_t START1 = 0x94;
+constexpr uint8_t SERIALHAL_MAGIC = 0xA5;
+constexpr size_t HEADER_SIZE = 4; // START1 + SERIALHAL_MAGIC + LEN_H + LEN_L
+constexpr uint8_t START2 = 0xC3;  // second byte of a normal FromRadio frame
+
+speed_t toTermiosBaud(uint32_t baud)
+{
+    switch (baud) {
+    case 9600:
+        return B9600;
+    case 19200:
+        return B19200;
+    case 38400:
+        return B38400;
+    case 57600:
+        return B57600;
+    case 115200:
+        return B115200;
+    case 230400:
+        return B230400;
+    case 460800:
+        return B460800;
+    case 921600:
+        return B921600;
+    default:
+        return B115200;
+    }
+}
+} // namespace
+
+SerialHal::SerialHal(const std::string &devicePath, uint32_t baudRate, uint32_t opTimeoutMs)
+    : RadioLibHal(SERIAL_PI_INPUT, SERIAL_PI_OUTPUT, SERIAL_PI_LOW, SERIAL_PI_HIGH, SERIAL_PI_RISING, SERIAL_PI_FALLING),
+      device(devicePath), baud(baudRate), timeoutMs(opTimeoutMs)
+{
+    if (!openPort()) {
+        setTransportError("unable to open serial device");
+    }
+}
+
+SerialHal::~SerialHal()
+{
+    closePort();
+}
+
+bool SerialHal::openPort()
+{
+    closePort();
+    fd = ::open(device.c_str(), O_RDWR | O_NOCTTY | O_SYNC);
+    if (fd < 0) {
+        return false;
+    }
+
+    termios tty = {};
+    if (tcgetattr(fd, &tty) != 0) {
+        closePort();
+        return false;
+    }
+
+    // Force raw mode to avoid line discipline byte mangling on binary frames.
+    cfmakeraw(&tty);
+
+    cfsetospeed(&tty, toTermiosBaud(baud));
+    cfsetispeed(&tty, toTermiosBaud(baud));
+
+    tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;
+    tty.c_cc[VMIN] = 0;
+    tty.c_cc[VTIME] = 0;
+    tty.c_cflag |= (CLOCAL | CREAD);
+    tty.c_cflag &= ~(PARENB | PARODD);
+    tty.c_cflag &= ~CSTOPB;
+    tty.c_cflag &= ~CRTSCTS;
+
+    if (tcsetattr(fd, TCSANOW, &tty) != 0) {
+        closePort();
+        return false;
+    }
+
+    tcflush(fd, TCIOFLUSH);
+    inError = false;
+    startReaderThread();
+    return true;
+}
+
+void SerialHal::closePort()
+{
+    stopReaderThread();
+    if (fd >= 0) {
+        ::close(fd);
+        fd = -1;
+    }
+}
+
+void SerialHal::setTransportError(const char *msg)
+{
+    if (!inError.load() || !hasWarned) {
+        LOG_ERROR("SerialHal: %s (%s)", msg, device.c_str());
+    }
+    inError = true;
+    hasWarned = true;
+    portduino_status.LoRa_in_error = true;
+}
+
+bool SerialHal::waitForReadable(int timeout)
+{
+    if (fd < 0) {
+        return false;
+    }
+    pollfd pfd = {};
+    pfd.fd = fd;
+    pfd.events = POLLIN;
+    int ret = poll(&pfd, 1, timeout);
+    return ret > 0 && (pfd.revents & POLLIN);
+}
+
+bool SerialHal::writeAll(const uint8_t *data, size_t len)
+{
+    size_t off = 0;
+    while (off < len) {
+        ssize_t rc = ::write(fd, data + off, len - off);
+        if (rc < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return false;
+        }
+        off += (size_t)rc;
+    }
+    return true;
+}
+
+bool SerialHal::readExact(uint8_t *data, size_t len)
+{
+    size_t off = 0;
+    auto start = std::chrono::steady_clock::now();
+    while (off < len) {
+        auto now = std::chrono::steady_clock::now();
+        int elapsed = (int)std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();
+        int remaining = (int)timeoutMs - elapsed;
+        if (remaining <= 0 || !waitForReadable(remaining)) {
+            return false;
+        }
+        ssize_t rc = ::read(fd, data + off, len - off);
+        if (rc < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return false;
+        }
+        if (rc == 0) {
+            return false;
+        }
+        off += (size_t)rc;
+    }
+    return true;
+}
+
+uint16_t SerialHal::crc16(const uint8_t *data, size_t len) const
+{
+    uint16_t crc = 0xFFFF;
+    for (size_t i = 0; i < len; ++i) {
+        crc ^= ((uint16_t)data[i] << 8);
+        for (int bit = 0; bit < 8; ++bit) {
+            if (crc & 0x8000) {
+                crc = (uint16_t)((crc << 1) ^ 0x1021);
+            } else {
+                crc = (uint16_t)(crc << 1);
+            }
+        }
+    }
+    return crc;
+}
+
+bool SerialHal::sendRequest(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse *response)
+{
+    if (fd < 0 && !openPort()) {
+        setTransportError("serial open failed");
+        return false;
+    }
+
+    uint8_t encoded[meshtastic_SerialHalCommand_size] = {0};
+    const size_t payloadLen =
+        pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_SerialHalCommand_msg, static_cast<const void *>(&cmd));
+    if (payloadLen == 0 || payloadLen > 0xFFFF) {
+        setTransportError("serial command encode failed");
+        return false;
+    }
+
+    // Build frame with StreamAPI canonical framing: START1 SERIALHAL_MAGIC LEN_H LEN_L [payload]
+    std::vector<uint8_t> frame;
+    frame.resize(HEADER_SIZE + payloadLen);
+
+    frame[0] = START1;
+    frame[1] = SERIALHAL_MAGIC;
+    frame[2] = (uint8_t)((payloadLen >> 8) & 0xFF); // LEN_H (big-endian)
+    frame[3] = (uint8_t)(payloadLen & 0xFF);        // LEN_L
+    memcpy(frame.data() + HEADER_SIZE, encoded, payloadLen);
+
+    {
+        std::lock_guard<std::mutex> writeGuard(writeMutex);
+        if (!writeAll(frame.data(), frame.size())) {
+            setTransportError("serial write failed");
+            return false;
+        }
+    }
+
+    meshtastic_SerialHalResponse got = meshtastic_SerialHalResponse_init_zero;
+    {
+        std::unique_lock<std::mutex> lock(stateMutex);
+        const auto timeout = std::chrono::milliseconds(timeoutMs);
+        const bool arrived = responseCv.wait_for(lock, timeout, [&]() { return pendingResponses.count(cmd.transaction_id) > 0; });
+        if (!arrived) {
+            setTransportError("serial response timeout");
+            LOG_WARN("SerialHal: response timeout for transaction_id %u, cmd type %u", cmd.transaction_id, cmd.type);
+            return false;
+        }
+
+        got = pendingResponses[cmd.transaction_id];
+        pendingResponses.erase(cmd.transaction_id);
+    }
+
+    if (got.result != meshtastic_SerialHalResponse_Result_OK) {
+        setTransportError("serial response reported error");
+        LOG_WARN("SerialHal: response error: %s, %u, %u", got.error, cmd.type, cmd.data.size);
+
+        return false;
+    }
+
+    if (response != nullptr) {
+        *response = got;
+    }
+
+    inError = false;
+    hasWarned = false;
+    return true;
+}
+
+void SerialHal::pinMode(uint32_t pin, uint32_t mode)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_PIN_MODE;
+    cmd.pin = pin;
+    cmd.mode = mode;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::digitalWrite(uint32_t pin, uint32_t value)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DIGITAL_WRITE;
+    cmd.pin = pin;
+    cmd.value = value;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+uint32_t SerialHal::digitalRead(uint32_t pin)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return 0;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DIGITAL_READ;
+    cmd.pin = pin;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    if (!sendRequest(cmd, &response)) {
+        return 0;
+    }
+    return response.value;
+}
+
+void SerialHal::attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode)
+{
+    if (checkError() || interruptNum == RADIOLIB_NC) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(stateMutex);
+        interruptCallbacks[interruptNum] = interruptCb;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT;
+    cmd.pin = interruptNum;
+    cmd.mode = mode;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::detachInterrupt(uint32_t interruptNum)
+{
+    if (checkError() || interruptNum == RADIOLIB_NC) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(stateMutex);
+        interruptCallbacks.erase(interruptNum);
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT;
+    cmd.pin = interruptNum;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::delay(unsigned long ms)
+{
+    delayMicroseconds(ms * 1000);
+}
+
+void SerialHal::delayMicroseconds(unsigned long us)
+{
+    if (us == 0) {
+        sched_yield();
+        return;
+    }
+    usleep(us);
+}
+
+void SerialHal::yield()
+{
+    sched_yield();
+}
+
+unsigned long SerialHal::millis()
+{
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return (tv.tv_sec * 1000ULL) + (tv.tv_usec / 1000ULL);
+}
+
+unsigned long SerialHal::micros()
+{
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return (tv.tv_sec * 1000000ULL) + tv.tv_usec;
+}
+
+long SerialHal::pulseIn(uint32_t pin, uint32_t state, unsigned long timeout)
+{
+    (void)pin;
+    (void)state;
+    (void)timeout;
+    LOG_WARN("SerialHal pulseIn is not supported");
+    return 0;
+}
+
+void SerialHal::spiTransfer(uint8_t *out, size_t len, uint8_t *in)
+{
+    if (checkError()) {
+        return;
+    }
+
+    if (len == 0) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_SPI_TRANSFER;
+
+    const size_t maxTx = sizeof(cmd.data.bytes);
+    const size_t txLen = len < maxTx ? len : maxTx;
+    cmd.data.size = txLen;
+    if (out != nullptr) {
+        memcpy(cmd.data.bytes, out, txLen);
+    } else {
+        memset(cmd.data.bytes, 0, txLen);
+    }
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    if (!sendRequest(cmd, &response)) {
+        return;
+    }
+
+    if (in != nullptr) {
+        size_t copyLen = response.data.size < len ? response.data.size : len;
+        memcpy(in, response.data.bytes, copyLen);
+        if (copyLen < len) {
+            memset(in + copyLen, 0, len - copyLen);
+        }
+    }
+}
+
+bool SerialHal::checkError()
+{
+    if (inError.load()) {
+        if (!hasWarned) {
+            LOG_ERROR("SerialHal in_error detected");
+            hasWarned = true;
+        }
+        portduino_status.LoRa_in_error = true;
+        return true;
+    }
+    hasWarned = false;
+    return false;
+}
+
+bool SerialHal::readFrame(std::vector<uint8_t> &payload, int firstByteTimeoutMs)
+{
+    payload.clear();
+
+    // Loop so that normal FromRadio frames (START1 START2 ...) emitted by the
+    // device on the same serial port are drained and discarded rather than
+    // causing the byte stream to desync.
+    for (;;) {
+        uint8_t hdr[HEADER_SIZE] = {0};
+        for (;;) {
+
+            ssize_t rc = ::read(fd, &hdr[0], 1);
+            if (rc < 0) {
+                if (errno == EINTR) {
+                    continue;
+                }
+                return false;
+            }
+            if (rc == 0) {
+                return false;
+            }
+            if (hdr[0] == START1) {
+                break;
+            }
+        }
+
+        if (!readExact(hdr + 1, HEADER_SIZE - 1)) {
+            return false;
+        }
+
+        const uint16_t len = ((uint16_t)hdr[2] << 8) | (uint16_t)hdr[3];
+
+        if (hdr[1] == SERIALHAL_MAGIC) {
+            // SerialHal response frame — this is what we want.
+            if (len > meshtastic_SerialHalResponse_size) {
+                return false;
+            }
+            payload.resize(len);
+            if (len > 0 && !readExact(payload.data(), len)) {
+                payload.clear();
+                return false;
+            }
+            return true;
+        } else if (hdr[1] == START2) {
+            // Normal FromRadio frame emitted by the device — drain and discard
+            // its payload so we stay in sync, then loop to find a SerialHal frame.
+            if (len > 0) {
+                std::vector<uint8_t> discard(len);
+                if (!readExact(discard.data(), len)) {
+                    return false;
+                }
+            }
+            // continue looping, look for next frame
+        } else {
+            // Unknown second byte after START1 — restart search for framing.
+            continue;
+        }
+    }
+}
+
+void SerialHal::readerLoop()
+{
+    readerRunning = true;
+    while (!readerStopRequested.load()) {
+        if (fd < 0) {
+            break;
+        }
+
+        if (!waitForReadable(100)) {
+            continue;
+        }
+
+        std::vector<uint8_t> payload;
+        if (!readFrame(payload, 40)) {
+            continue;
+        }
+
+        meshtastic_SerialHalResponse resp = meshtastic_SerialHalResponse_init_zero;
+        if (payload.empty() || !pb_decode_from_bytes(payload.data(), payload.size(), &meshtastic_SerialHalResponse_msg, &resp)) {
+            continue;
+        }
+
+        if (resp.transaction_id == 0) {
+            LOG_WARN("SerialHal: received unsolicited interrupt event: pin=%u", resp.value);
+            // transaction_id 0 is reserved for unsolicited interrupt events.
+            // The device reports the triggered pin in resp.value instead of
+            // matching one of the synchronous request/response transactions.
+            {
+                std::lock_guard<std::mutex> lock(stateMutex);
+                if (interruptCallbacks.count(resp.value) > 0) {
+                    pendingInterruptPins.push_back(resp.value);
+                }
+            }
+            interruptCv.notify_one();
+            continue;
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(stateMutex);
+            pendingResponses[resp.transaction_id] = resp;
+        }
+        responseCv.notify_all();
+    }
+    readerRunning = false;
+}
+
+void SerialHal::interruptDispatchLoop()
+{
+    interruptDispatcherRunning = true;
+    while (!readerStopRequested.load()) {
+        uint32_t pin = 0;
+        void (*cb)(void) = nullptr;
+
+        {
+            std::unique_lock<std::mutex> lock(stateMutex);
+            interruptCv.wait(lock, [&]() { return readerStopRequested.load() || !pendingInterruptPins.empty(); });
+            if (readerStopRequested.load()) {
+                break;
+            }
+
+            pin = pendingInterruptPins.front();
+            pendingInterruptPins.pop_front();
+
+            auto it = interruptCallbacks.find(pin);
+            if (it != interruptCallbacks.end()) {
+                cb = it->second;
+            }
+        }
+
+        if (cb != nullptr) {
+            cb();
+        }
+    }
+    interruptDispatcherRunning = false;
+}
+
+void SerialHal::startReaderThread()
+{
+    stopReaderThread();
+    readerStopRequested = false;
+    readerThread = std::thread(&SerialHal::readerLoop, this);
+    interruptThread = std::thread(&SerialHal::interruptDispatchLoop, this);
+}
+
+void SerialHal::stopReaderThread()
+{
+    readerStopRequested = true;
+    interruptCv.notify_all();
+    if (readerThread.joinable()) {
+        readerThread.join();
+    }
+    if (interruptThread.joinable()) {
+        interruptThread.join();
+    }
+
+    std::lock_guard<std::mutex> lock(stateMutex);
+    pendingInterruptPins.clear();
+}
@@ -0,0 +1,99 @@
+#ifndef PI_HAL_SERIAL_H
+#define PI_HAL_SERIAL_H
+
+#include <RadioLib.h>
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <mesh/generated/meshtastic/serial_hal.pb.h>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#define SERIAL_PI_INPUT (0)
+#define SERIAL_PI_OUTPUT (1)
+#define SERIAL_PI_LOW (0)
+#define SERIAL_PI_HIGH (1)
+#define SERIAL_PI_RISING (1)
+#define SERIAL_PI_FALLING (2)
+
+class SerialHal : public RadioLibHal
+{
+  public:
+    explicit SerialHal(const std::string &device, uint32_t baud = 115200, uint32_t timeoutMs = 500);
+    ~SerialHal() override;
+
+    void init() override {}
+    void term() override {}
+
+    void pinMode(uint32_t pin, uint32_t mode) override;
+    void digitalWrite(uint32_t pin, uint32_t value) override;
+    uint32_t digitalRead(uint32_t pin) override;
+
+    void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override;
+    void detachInterrupt(uint32_t interruptNum) override;
+
+    void delay(unsigned long ms) override;
+    void delayMicroseconds(unsigned long us) override;
+    void yield() override;
+
+    unsigned long millis() override;
+    unsigned long micros() override;
+
+    long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override;
+
+    void spiBegin() override {}
+    void spiBeginTransaction() override {}
+    void spiTransfer(uint8_t *out, size_t len, uint8_t *in) override;
+    void spiEndTransaction() override {}
+    void spiEnd() override {}
+
+    bool checkError();
+
+  private:
+    bool openPort();
+    void closePort();
+    bool sendRequest(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse *response);
+    bool writeAll(const uint8_t *data, size_t len);
+    bool readExact(uint8_t *data, size_t len);
+    bool waitForReadable(int timeoutMs);
+    bool readFrame(std::vector<uint8_t> &payload, int firstByteTimeoutMs);
+    void readerLoop();
+    void interruptDispatchLoop();
+    void startReaderThread();
+    void stopReaderThread();
+
+    uint16_t crc16(const uint8_t *data, size_t len) const;
+    void setTransportError(const char *msg);
+
+    std::string device;
+    uint32_t baud;
+    uint32_t timeoutMs;
+    int fd = -1;
+    bool hasWarned = false;
+    std::atomic<bool> inError{false};
+    std::atomic<uint16_t> txId{1};
+
+    std::mutex fdMutex;
+    std::mutex writeMutex;
+    std::mutex stateMutex;
+    std::condition_variable responseCv;
+
+    std::thread readerThread;
+    std::thread interruptThread;
+    std::atomic<bool> readerStopRequested{false};
+    std::atomic<bool> readerRunning{false};
+    std::atomic<bool> interruptDispatcherRunning{false};
+
+    std::condition_variable interruptCv;
+    std::deque<uint32_t> pendingInterruptPins;
+
+    std::unordered_map<uint32_t, void (*)(void)> interruptCallbacks;
+    std::unordered_map<uint16_t, meshtastic_SerialHalResponse> pendingResponses;
+};
+
+#endif
@@ -0,0 +1,465 @@
+// Unit tests for NextHop direct-message reliability mitigations (see docs/nexthop-routing-reliability.md):
+//   M1 - NodeDB::resolveLastByte / resolveUniqueLastByte (ambiguity-aware last-byte resolution)
+//   M2 - NextHopRouter::getNextHop strict-neighbor gate + Router::shouldDecrementHopLimit favorite check
+//   M3 - NextHopRouter route-health freshness / failure decay
+//
+// Time handling: the route-health helpers take `now` as a parameter so the 30-minute TTL logic is
+// pure and testable without a clock mock. getNextHop()/sinceLastSeen() use the real native clock;
+// we back-date timestamps relative to it, and the unsigned-subtraction age math is rollover-safe.
+
+#include "MeshTypes.h" // before TestUtil.h: provides NodeNum etc.
+#include "TestUtil.h"
+#include <unity.h>
+
+#include "configuration.h"
+#include "gps/RTC.h"
+#include "mesh/NextHopRouter.h"
+#include "mesh/NodeDB.h"
+#include <cstdio>
+#include <cstring>
+#include <memory>
+
+#define MSG_BUF_LEN 200
+#define TEST_MSG_FMT(fmt, ...)                                                                                                   \
+    do {                                                                                                                         \
+        char _buf[MSG_BUF_LEN];                                                                                                  \
+        snprintf(_buf, sizeof(_buf), fmt, __VA_ARGS__);                                                                          \
+        TEST_MESSAGE(_buf);                                                                                                      \
+    } while (0)
+
+static constexpr NodeNum kLocalNode = 0x11111111; // last byte 0x11
+
+// ---------------------------------------------------------------------------
+// MockNodeDB — inject nodes with controlled last byte, hop distance, age, role, favorite flag.
+// ---------------------------------------------------------------------------
+class MockNodeDB : public NodeDB
+{
+  public:
+    void clearTestNodes()
+    {
+        testNodes.clear();
+        meshNodes = &testNodes;
+        numMeshNodes = 0;
+    }
+
+    // ageSecs is how long ago we last heard the node; getTime() returns a large Unix timestamp on
+    // native, so getTime()-ageSecs does not underflow for the ranges used here.
+    void addNode(NodeNum num, uint8_t hopsAway, bool hasHops, uint32_t ageSecs,
+                 meshtastic_Config_DeviceConfig_Role role = meshtastic_Config_DeviceConfig_Role_CLIENT, bool favorite = false,
+                 bool ignored = false, uint8_t nextHop = NO_NEXT_HOP_PREFERENCE)
+    {
+        meshtastic_NodeInfoLite node = meshtastic_NodeInfoLite_init_zero;
+        node.num = num;
+        node.has_hops_away = hasHops;
+        node.hops_away = hopsAway;
+        node.role = role;
+        node.next_hop = nextHop;
+        node.last_heard = getTime() - ageSecs;
+        nodeInfoLiteSetBit(&node, NODEINFO_BITFIELD_IS_FAVORITE_MASK, favorite);
+        nodeInfoLiteSetBit(&node, NODEINFO_BITFIELD_IS_IGNORED_MASK, ignored);
+        nodeInfoLiteSetBit(&node, NODEINFO_BITFIELD_HAS_USER_MASK, true);
+        testNodes.push_back(node);
+        meshNodes = &testNodes;
+        numMeshNodes = testNodes.size();
+    }
+
+    std::vector<meshtastic_NodeInfoLite> testNodes;
+};
+
+// ---------------------------------------------------------------------------
+// Test shim — expose getNextHop and the route-health helpers; reset health between tests.
+// Nulls cryptLock so the Router base can be (re)constructed (same pattern as test_mqtt MockRouter).
+// ---------------------------------------------------------------------------
+class NextHopRouterTestShim : public NextHopRouter
+{
+  public:
+    NextHopRouterTestShim() : NextHopRouter()
+    {
+        delete cryptLock;
+        cryptLock = nullptr;
+    }
+
+    using NextHopRouter::clearRouteHealth;
+    using NextHopRouter::findRouteHealth;
+    using NextHopRouter::getNextHop;
+    using NextHopRouter::getOrAllocRouteHealth;
+    using NextHopRouter::isRouteStale;
+    using NextHopRouter::noteRouteFailure;
+    using NextHopRouter::noteRouteLearned;
+    using NextHopRouter::noteRouteSuccess;
+    using Router::shouldDecrementHopLimit; // protected in Router
+
+    void resetRouteHealthForTest()
+    {
+        for (auto &h : routeHealth)
+            h = RouteHealth{};
+    }
+};
+
+static MockNodeDB *mockNodeDB = nullptr;
+static NextHopRouterTestShim *shim = nullptr;
+
+static constexpr uint32_t TTL = NextHopRouter::ROUTE_TTL_MSEC;
+static constexpr uint8_t THRESH = NextHopRouter::ROUTE_FAILURE_THRESHOLD;
+static constexpr uint8_t HEALTH_MAX = NextHopRouter::ROUTE_HEALTH_MAX;
+
+// Helper: a decoded packet whose hops-away is `hopsAway`, relayed by last byte `relay`.
+static meshtastic_MeshPacket makeRelayedPacket(uint8_t relay, uint8_t hopsAway)
+{
+    meshtastic_MeshPacket p = meshtastic_MeshPacket_init_zero;
+    p.which_payload_variant = meshtastic_MeshPacket_decoded_tag;
+    p.relay_node = relay;
+    p.hop_start = 4;
+    p.hop_limit = 4 - hopsAway; // getHopsAway() == hop_start - hop_limit
+    return p;
+}
+
+void setUp(void)
+{
+    myNodeInfo.my_node_num = kLocalNode;
+    config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
+    mockNodeDB->clearTestNodes();
+    shim->resetRouteHealthForTest();
+}
+
+void tearDown(void) {}
+
+// ===========================================================================
+// Group 1 — resolveLastByte (M1)
+// ===========================================================================
+
+void test_resolve_none_when_empty(void)
+{
+    ResolvedNode r = mockNodeDB->resolveLastByte(0xAB, true);
+    TEST_ASSERT_EQUAL(LastByteResolution::None, r.status);
+}
+
+void test_resolve_zero_byte_is_none(void)
+{
+    // 0 is the NO_RELAY_NODE / NO_NEXT_HOP_PREFERENCE sentinel — never resolves.
+    mockNodeDB->addNode(0x22222200, 0, true, 60); // last byte maps to 0xFF, not 0
+    TEST_ASSERT_EQUAL(LastByteResolution::None, mockNodeDB->resolveLastByte(0x00, true).status);
+    TEST_ASSERT_EQUAL(LastByteResolution::None, mockNodeDB->resolveLastByte(0x00, false).status);
+}
+
+void test_resolve_unique_neighbor(void)
+{
+    mockNodeDB->addNode(0x000005AB, 0, true, 60); // direct, fresh, last byte 0xAB
+    ResolvedNode r = mockNodeDB->resolveLastByte(0xAB, true);
+    TEST_ASSERT_EQUAL(LastByteResolution::Unique, r.status);
+    TEST_ASSERT_EQUAL_HEX32(0x000005AB, r.num);
+}
+
+void test_resolve_collision_is_ambiguous(void)
+{
+    // Birthday collision: two fresh direct neighbors share last byte 0xAB.
+    mockNodeDB->addNode(0x000005AB, 0, true, 60);
+    mockNodeDB->addNode(0x000006AB, 0, true, 60);
+    ResolvedNode r = mockNodeDB->resolveLastByte(0xAB, true);
+    TEST_ASSERT_EQUAL(LastByteResolution::Ambiguous, r.status);
+    TEST_ASSERT_EQUAL_HEX32(0, r.num); // never silently picks one
+}
+
+void test_resolve_strict_excludes_stale(void)
+{
+    mockNodeDB->addNode(0x000005AB, 0, true, 60);                                // fresh
+    mockNodeDB->addNode(0x000006AB, 0, true, NEXTHOP_NEIGHBOR_FRESH_SECS + 100); // stale
+    ResolvedNode r = mockNodeDB->resolveLastByte(0xAB, true);
+    TEST_ASSERT_EQUAL(LastByteResolution::Unique, r.status);
+    TEST_ASSERT_EQUAL_HEX32(0x000005AB, r.num);
+}
+
+void test_resolve_strict_excludes_far(void)
+{
+    mockNodeDB->addNode(0x000005AB, 0, true, 60); // direct neighbor
+    mockNodeDB->addNode(0x000006AB, 2, true, 60); // 2 hops away -> not a direct neighbor
+    ResolvedNode r = mockNodeDB->resolveLastByte(0xAB, true);
+    TEST_ASSERT_EQUAL(LastByteResolution::Unique, r.status);
+    TEST_ASSERT_EQUAL_HEX32(0x000005AB, r.num);
+}
+
+void test_resolve_lenient_includes_favorite_router(void)
+{
+    // Unknown hop distance, but a favorite ROUTER: lenient gate accepts, strict gate does not.
+    mockNodeDB->addNode(0x000007AB, 0, false, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/true);
+    TEST_ASSERT_EQUAL(LastByteResolution::Unique, mockNodeDB->resolveLastByte(0xAB, false).status);
+    TEST_ASSERT_EQUAL(LastByteResolution::None, mockNodeDB->resolveLastByte(0xAB, true).status);
+}
+
+void test_resolve_lenient_collision_favorite_plus_neighbor(void)
+{
+    mockNodeDB->addNode(0x000007AB, 0, false, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/true);
+    mockNodeDB->addNode(0x000005AB, 0, true, 60); // direct neighbor, same byte
+    TEST_ASSERT_EQUAL(LastByteResolution::Ambiguous, mockNodeDB->resolveLastByte(0xAB, false).status);
+}
+
+void test_resolve_skips_self(void)
+{
+    // A node equal to us (last byte 0x11) must never resolve to ourselves.
+    mockNodeDB->addNode(kLocalNode, 0, true, 60);
+    TEST_ASSERT_EQUAL(LastByteResolution::None, mockNodeDB->resolveLastByte(0x11, true).status);
+}
+
+void test_resolve_skips_ignored(void)
+{
+    mockNodeDB->addNode(0x000005AB, 0, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, /*ignored=*/true);
+    TEST_ASSERT_EQUAL(LastByteResolution::None, mockNodeDB->resolveLastByte(0xAB, true).status);
+}
+
+void test_resolve_0x00_maps_to_0xFF_and_collides(void)
+{
+    // getLastByteOfNodeNum() maps ...00 -> 0xFF, so a ...00 node and a ...FF node collide on 0xFF.
+    TEST_ASSERT_EQUAL_HEX8(0xFF, mockNodeDB->getLastByteOfNodeNum(0x11111100));
+    mockNodeDB->addNode(0x11111100, 0, true, 60); // last byte 0xFF (remapped)
+    TEST_ASSERT_EQUAL(LastByteResolution::Unique, mockNodeDB->resolveLastByte(0xFF, true).status);
+    mockNodeDB->addNode(0x222222FF, 0, true, 60); // genuine ...FF
+    TEST_ASSERT_EQUAL(LastByteResolution::Ambiguous, mockNodeDB->resolveLastByte(0xFF, true).status);
+}
+
+void test_resolve_unique_helper(void)
+{
+    mockNodeDB->addNode(0x000005AB, 0, true, 60);
+    NodeNum out = 0;
+    TEST_ASSERT_TRUE(mockNodeDB->resolveUniqueLastByte(0xAB, true, &out));
+    TEST_ASSERT_EQUAL_HEX32(0x000005AB, out);
+    mockNodeDB->addNode(0x000006AB, 0, true, 60); // create collision
+    TEST_ASSERT_FALSE(mockNodeDB->resolveUniqueLastByte(0xAB, true));
+}
+
+// ===========================================================================
+// Group 2 — getNextHop (M2 send-path gate + M3 decay)
+// ===========================================================================
+
+static constexpr NodeNum DEST = 0x000000B0; // DM destination (last byte 0xB0, distinct from 0xAB)
+
+void test_getnexthop_unique_returns_byte(void)
+{
+    mockNodeDB->addNode(DEST, 2, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, false, /*nextHop=*/0xAB);
+    mockNodeDB->addNode(0x000005AB, 0, true, 60); // unique fresh neighbor with byte 0xAB
+    auto nh = shim->getNextHop(DEST, /*relay=*/0x11);
+    TEST_ASSERT_TRUE(nh.has_value());
+    TEST_ASSERT_EQUAL_HEX8(0xAB, nh.value());
+}
+
+void test_getnexthop_ambiguous_floods(void)
+{
+    mockNodeDB->addNode(DEST, 2, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, false, /*nextHop=*/0xAB);
+    mockNodeDB->addNode(0x000005AB, 0, true, 60);
+    mockNodeDB->addNode(0x000006AB, 0, true, 60); // collision -> ambiguous
+    TEST_ASSERT_FALSE(shim->getNextHop(DEST, 0x11).has_value());
+}
+
+void test_getnexthop_vanished_neighbor_floods(void)
+{
+    mockNodeDB->addNode(DEST, 2, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, false, /*nextHop=*/0xAB);
+    // The only 0xAB node is stale -> strict gate yields None -> flood.
+    mockNodeDB->addNode(0x000005AB, 0, true, NEXTHOP_NEIGHBOR_FRESH_SECS + 100);
+    TEST_ASSERT_FALSE(shim->getNextHop(DEST, 0x11).has_value());
+}
+
+void test_getnexthop_split_horizon_floods(void)
+{
+    mockNodeDB->addNode(DEST, 2, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, false, /*nextHop=*/0xAB);
+    mockNodeDB->addNode(0x000005AB, 0, true, 60);
+    // relay_node == stored next_hop -> don't send it back the way it came.
+    TEST_ASSERT_FALSE(shim->getNextHop(DEST, /*relay=*/0xAB).has_value());
+}
+
+void test_getnexthop_broadcast_is_nullopt(void)
+{
+    TEST_ASSERT_FALSE(shim->getNextHop(NODENUM_BROADCAST, 0x11).has_value());
+}
+
+void test_getnexthop_decays_stale_route(void)
+{
+    mockNodeDB->addNode(DEST, 2, true, 60, meshtastic_Config_DeviceConfig_Role_CLIENT, false, false, /*nextHop=*/0xAB);
+    mockNodeDB->addNode(0x000005AB, 0, true, 60); // a valid unique neighbor exists...
+    // ...but the health record is older than the TTL, so the route should decay to flooding.
+    shim->noteRouteLearned(DEST, 0xAB, millis() - (TTL + 5000));
+    TEST_ASSERT_FALSE(shim->getNextHop(DEST, 0x11).has_value());
+    // Decay also clears the persisted next_hop and the RAM health record.
+    TEST_ASSERT_EQUAL_HEX8(NO_NEXT_HOP_PREFERENCE, mockNodeDB->getMeshNode(DEST)->next_hop);
+    TEST_ASSERT_NULL(shim->findRouteHealth(DEST));
+}
+
+// ===========================================================================
+// Group 3 — route-health helpers (M3)
+// ===========================================================================
+
+void test_health_fresh_not_stale(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    RouteHealth *h = shim->findRouteHealth(DEST);
+    TEST_ASSERT_NOT_NULL(h);
+    TEST_ASSERT_FALSE(shim->isRouteStale(*h, 1000 + TTL - 1));
+}
+
+void test_health_ttl_expiry(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    RouteHealth *h = shim->findRouteHealth(DEST);
+    TEST_ASSERT_TRUE(shim->isRouteStale(*h, 1000 + TTL)); // boundary is inclusive (>=)
+}
+
+void test_health_ttl_rollover_safe(void)
+{
+    const uint32_t learnAt = 0xFFFFFFFFu - 1000; // learned just before the millis() rollover
+    shim->noteRouteLearned(DEST, 0xAB, learnAt);
+    RouteHealth *h = shim->findRouteHealth(DEST);
+    // 1500 ms later (wrapped to now=500): unsigned subtraction yields ~1500 ms, not "stale".
+    TEST_ASSERT_FALSE(shim->isRouteStale(*h, 500));
+}
+
+void test_health_failure_threshold(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    for (uint8_t i = 1; i < THRESH; i++)
+        shim->noteRouteFailure(DEST);
+    TEST_ASSERT_FALSE(shim->isRouteStale(*shim->findRouteHealth(DEST), 1000)); // THRESH-1 failures: ok
+    shim->noteRouteFailure(DEST);
+    TEST_ASSERT_TRUE(shim->isRouteStale(*shim->findRouteHealth(DEST), 1000)); // THRESH failures: stale
+}
+
+void test_health_success_resets_failures(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteSuccess(DEST, 2000);
+    RouteHealth *h = shim->findRouteHealth(DEST);
+    TEST_ASSERT_EQUAL_UINT8(0, h->consecutiveFailures);
+    TEST_ASSERT_FALSE(shim->isRouteStale(*h, 2000));
+}
+
+void test_health_relearn_same_hop_keeps_failures(void)
+{
+    // Anti-flap: an asymmetric reverse path re-teaching the same dead hop must not reset failures.
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteLearned(DEST, 0xAB, 2000); // same hop
+    TEST_ASSERT_EQUAL_UINT8(2, shim->findRouteHealth(DEST)->consecutiveFailures);
+}
+
+void test_health_relearn_new_hop_resets_failures(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteFailure(DEST);
+    shim->noteRouteLearned(DEST, 0xCD, 2000); // genuinely new hop -> clean slate
+    RouteHealth *h = shim->findRouteHealth(DEST);
+    TEST_ASSERT_EQUAL_UINT8(0, h->consecutiveFailures);
+    TEST_ASSERT_EQUAL_HEX8(0xCD, h->lastNextHop);
+}
+
+void test_health_failure_without_record_is_noop(void)
+{
+    shim->noteRouteFailure(DEST); // no record yet
+    TEST_ASSERT_NULL(shim->findRouteHealth(DEST));
+}
+
+void test_health_clear(void)
+{
+    shim->noteRouteLearned(DEST, 0xAB, 1000);
+    TEST_ASSERT_NOT_NULL(shim->findRouteHealth(DEST));
+    shim->clearRouteHealth(DEST);
+    TEST_ASSERT_NULL(shim->findRouteHealth(DEST));
+}
+
+void test_health_lru_eviction_bounds_table(void)
+{
+    // Fill every slot with increasing learn times, then add one more: the oldest must be evicted.
+    for (uint8_t i = 0; i < HEALTH_MAX; i++)
+        shim->noteRouteLearned(0x1000 + i, 0xAB, 1000 + (uint32_t)i * 1000);
+    NodeNum oldest = 0x1000;
+    TEST_ASSERT_NOT_NULL(shim->findRouteHealth(oldest));
+    shim->noteRouteLearned(0x2000, 0xAB, 1000 + (uint32_t)HEALTH_MAX * 1000); // overflow
+    TEST_ASSERT_NULL(shim->findRouteHealth(oldest));                          // evicted
+    TEST_ASSERT_NOT_NULL(shim->findRouteHealth(0x2000));                      // newest present
+}
+
+// ===========================================================================
+// Group 4 — shouldDecrementHopLimit favorite-router resolution (M2, site 4)
+// ===========================================================================
+
+void test_hoplimit_preserve_unique_favorite_router(void)
+{
+    config.device.role = meshtastic_Config_DeviceConfig_Role_ROUTER;
+    mockNodeDB->addNode(0x000007AB, 0, true, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/true);
+    meshtastic_MeshPacket p = makeRelayedPacket(/*relay=*/0xAB, /*hopsAway=*/1);
+    TEST_ASSERT_FALSE(shim->shouldDecrementHopLimit(&p)); // preserve
+}
+
+void test_hoplimit_decrement_on_colliding_favorites(void)
+{
+    // Headline regression: two favorite routers share the relay byte -> ambiguous -> decrement
+    // (the old "first NodeDB match wins" scan would non-deterministically preserve).
+    config.device.role = meshtastic_Config_DeviceConfig_Role_ROUTER;
+    mockNodeDB->addNode(0x000007AB, 0, true, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/true);
+    mockNodeDB->addNode(0x000008AB, 0, true, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/true);
+    meshtastic_MeshPacket p = makeRelayedPacket(0xAB, 1);
+    TEST_ASSERT_TRUE(shim->shouldDecrementHopLimit(&p)); // decrement
+}
+
+void test_hoplimit_decrement_when_resolved_not_favorite(void)
+{
+    config.device.role = meshtastic_Config_DeviceConfig_Role_ROUTER;
+    mockNodeDB->addNode(0x000007AB, 0, true, 60, meshtastic_Config_DeviceConfig_Role_ROUTER, /*favorite=*/false);
+    meshtastic_MeshPacket p = makeRelayedPacket(0xAB, 1);
+    TEST_ASSERT_TRUE(shim->shouldDecrementHopLimit(&p)); // unique but not a favorite -> decrement
+}
+
+// ===========================================================================
+
+void setup()
+{
+    initializeTestEnvironment();
+    UNITY_BEGIN();
+
+    mockNodeDB = new MockNodeDB();
+    shim = new NextHopRouterTestShim();
+    nodeDB = mockNodeDB;
+
+    printf("\n=== resolveLastByte (M1) ===\n");
+    RUN_TEST(test_resolve_none_when_empty);
+    RUN_TEST(test_resolve_zero_byte_is_none);
+    RUN_TEST(test_resolve_unique_neighbor);
+    RUN_TEST(test_resolve_collision_is_ambiguous);
+    RUN_TEST(test_resolve_strict_excludes_stale);
+    RUN_TEST(test_resolve_strict_excludes_far);
+    RUN_TEST(test_resolve_lenient_includes_favorite_router);
+    RUN_TEST(test_resolve_lenient_collision_favorite_plus_neighbor);
+    RUN_TEST(test_resolve_skips_self);
+    RUN_TEST(test_resolve_skips_ignored);
+    RUN_TEST(test_resolve_0x00_maps_to_0xFF_and_collides);
+    RUN_TEST(test_resolve_unique_helper);
+
+    printf("\n=== getNextHop (M2 + M3 decay) ===\n");
+    RUN_TEST(test_getnexthop_unique_returns_byte);
+    RUN_TEST(test_getnexthop_ambiguous_floods);
+    RUN_TEST(test_getnexthop_vanished_neighbor_floods);
+    RUN_TEST(test_getnexthop_split_horizon_floods);
+    RUN_TEST(test_getnexthop_broadcast_is_nullopt);
+    RUN_TEST(test_getnexthop_decays_stale_route);
+
+    printf("\n=== route-health helpers (M3) ===\n");
+    RUN_TEST(test_health_fresh_not_stale);
+    RUN_TEST(test_health_ttl_expiry);
+    RUN_TEST(test_health_ttl_rollover_safe);
+    RUN_TEST(test_health_failure_threshold);
+    RUN_TEST(test_health_success_resets_failures);
+    RUN_TEST(test_health_relearn_same_hop_keeps_failures);
+    RUN_TEST(test_health_relearn_new_hop_resets_failures);
+    RUN_TEST(test_health_failure_without_record_is_noop);
+    RUN_TEST(test_health_clear);
+    RUN_TEST(test_health_lru_eviction_bounds_table);
+
+    printf("\n=== shouldDecrementHopLimit (M2 site 4) ===\n");
+    RUN_TEST(test_hoplimit_preserve_unique_favorite_router);
+    RUN_TEST(test_hoplimit_decrement_on_colliding_favorites);
+    RUN_TEST(test_hoplimit_decrement_when_resolved_not_favorite);
+
+    exit(UNITY_END());
+}
+
+void loop() {}
@@ -26,17 +26,22 @@ class NodeDBTestShim : public NodeDB
    void runDemote() { demoteOldestHotNodesToWarm(); }
    void runCleanup() { cleanupMeshDB(); }

+    // Read back the role + protected category the warm tier cached for a node.
+    bool warmMeta(NodeNum n, uint8_t &role, uint8_t &prot) { return warmStore.lookupMeta(n, role, prot); }
+
    void clearHot()
    {
        meshNodes->clear();
        numMeshNodes = 0;
    }

-    void push(NodeNum num, uint32_t lastHeard, bool favorite, bool ignored, bool withUser, bool withKey)
+    void push(NodeNum num, uint32_t lastHeard, bool favorite, bool ignored, bool withUser, bool withKey,
+              meshtastic_Config_DeviceConfig_Role role = meshtastic_Config_DeviceConfig_Role_CLIENT)
    {
        meshtastic_NodeInfoLite n = meshtastic_NodeInfoLite_init_zero;
        n.num = num;
        n.last_heard = lastHeard;
+        n.role = role;
        if (favorite)
            nodeInfoLiteSetBit(&n, NODEINFO_BITFIELD_IS_FAVORITE_MASK, true);
        if (ignored)
@@ -99,6 +104,34 @@ static void test_migration_demotesOldestKeepsKeepersAndSelf(void)
    TEST_ASSERT_TRUE(warmHasKey(2000 + 3));              // ...but its key kept in the warm tier
 }

+// Eviction carries the device role + protected category into the warm tier. A TRACKER is
+// hop-protected but NOT eviction-protected, so it gets demoted with its key; the warm
+// record must report role=TRACKER / category=Role. A plain CLIENT carries role=CLIENT/None.
+static void test_migration_carriesRoleAndProtectedIntoWarm(void)
+{
+    db->seedSelf();
+    const int extra = MAX_NUM_NODES + 30; // overflow so the oldest non-protected are demoted
+    for (int i = 1; i <= extra; i++) {
+        const auto role = (i == 3) ? meshtastic_Config_DeviceConfig_Role_TRACKER : meshtastic_Config_DeviceConfig_Role_CLIENT;
+        db->push(2000 + i, /*last_heard=*/i, /*favorite=*/false, /*ignored=*/false, /*withUser=*/true,
+                 /*withKey=*/true, role);
+    }
+
+    db->runDemote();
+
+    uint8_t role = 0xFF, prot = 0xFF;
+    // TRACKER (i=3): demoted out of hot, key kept, role + protected carried into warm.
+    TEST_ASSERT_NULL(db->getMeshNode(2000 + 3));
+    TEST_ASSERT_TRUE(warmHasKey(2000 + 3));
+    TEST_ASSERT_TRUE(db->warmMeta(2000 + 3, role, prot));
+    TEST_ASSERT_EQUAL(meshtastic_Config_DeviceConfig_Role_TRACKER, role);
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::Role, prot);
+    // CLIENT (i=4): also demoted, carries role=CLIENT / category=None.
+    TEST_ASSERT_TRUE(db->warmMeta(2000 + 4, role, prot));
+    TEST_ASSERT_EQUAL(meshtastic_Config_DeviceConfig_Role_CLIENT, role);
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::None, prot);
+}
+
 // Favourite handling: a favourite is never the eviction victim, even when it is
 // the oldest node in a full hot store.
 static void test_eviction_preservesFavorite(void)
@@ -172,6 +205,7 @@ NDB_TEST_ENTRY void setup()

    UNITY_BEGIN();
    RUN_TEST(test_migration_demotesOldestKeepsKeepersAndSelf);
+    RUN_TEST(test_migration_carriesRoleAndProtectedIntoWarm);
    RUN_TEST(test_eviction_preservesFavorite);
    RUN_TEST(test_ignored_survivesEvictionAndCleanup);
    RUN_TEST(test_protectedCap_refusesBeyondLimit);
@@ -0,0 +1,81 @@
+#include "TestUtil.h"
+#include "modules/PositionModule.h"
+#include <unity.h>
+
+// These exercise PositionModule's pure broadcast-policy helpers (stationary detection and the
+// interval floor). They take plain values, so no device globals or fake clock are needed.
+
+// Coordinates sharing the top `precision` bits land in the same grid cell.
+static void test_withinPrecisionCell_jitterStaysInCell()
+{
+    // At precision 16 the top 16 bits define the cell; the low 16 bits are GPS jitter.
+    TEST_ASSERT_TRUE(PositionModule::positionWithinPrecisionCell(0x12340000, 0x22340000, 0x1234ABCD, 0x2234EF01, 16));
+}
+
+static void test_withinPrecisionCell_movingLatLeavesCell()
+{
+    TEST_ASSERT_FALSE(PositionModule::positionWithinPrecisionCell(0x12340000, 0x22340000, 0x12350000, 0x22340000, 16));
+}
+
+static void test_withinPrecisionCell_movingLonLeavesCell()
+{
+    TEST_ASSERT_FALSE(PositionModule::positionWithinPrecisionCell(0x12340000, 0x22340000, 0x12340000, 0x22350000, 16));
+}
+
+// precision 0 means position sharing is off — never treat as stationary/suppressible.
+static void test_withinPrecisionCell_zeroPrecisionNeverSuppresses()
+{
+    TEST_ASSERT_FALSE(PositionModule::positionWithinPrecisionCell(0x12340000, 0x22340000, 0x12340000, 0x22340000, 0));
+}
+
+// Full precision (>=32): any difference matters, and identical full-precision coords still aren't
+// "stationary" because there's no coarse cell to hold within.
+static void test_withinPrecisionCell_fullPrecisionNeverSuppresses()
+{
+    TEST_ASSERT_FALSE(PositionModule::positionWithinPrecisionCell(0x12340000, 0x22340000, 0x12340000, 0x22340000, 32));
+}
+
+static void test_effectiveInterval_stationaryRaisesToFloor()
+{
+    TEST_ASSERT_EQUAL_UINT32(43200000U, PositionModule::effectiveBroadcastIntervalMs(60000U, true, 43200000U));
+}
+
+static void test_effectiveInterval_movingKeepsConfigured()
+{
+    TEST_ASSERT_EQUAL_UINT32(60000U, PositionModule::effectiveBroadcastIntervalMs(60000U, false, 43200000U));
+}
+
+// A configured interval already longer than the floor is never shortened.
+static void test_effectiveInterval_longConfiguredWinsOverFloor()
+{
+    TEST_ASSERT_EQUAL_UINT32(50000000U, PositionModule::effectiveBroadcastIntervalMs(50000000U, true, 43200000U));
+}
+
+static void test_effectiveInterval_zeroFloorIsNoOp()
+{
+    TEST_ASSERT_EQUAL_UINT32(60000U, PositionModule::effectiveBroadcastIntervalMs(60000U, true, 0U));
+}
+
+void setUp(void) {}
+
+void tearDown(void) {}
+
+extern "C" {
+void setup()
+{
+    initializeTestEnvironment();
+    UNITY_BEGIN();
+    RUN_TEST(test_withinPrecisionCell_jitterStaysInCell);
+    RUN_TEST(test_withinPrecisionCell_movingLatLeavesCell);
+    RUN_TEST(test_withinPrecisionCell_movingLonLeavesCell);
+    RUN_TEST(test_withinPrecisionCell_zeroPrecisionNeverSuppresses);
+    RUN_TEST(test_withinPrecisionCell_fullPrecisionNeverSuppresses);
+    RUN_TEST(test_effectiveInterval_stationaryRaisesToFloor);
+    RUN_TEST(test_effectiveInterval_movingKeepsConfigured);
+    RUN_TEST(test_effectiveInterval_longConfiguredWinsOverFloor);
+    RUN_TEST(test_effectiveInterval_zeroFloorIsNoOp);
+    exit(UNITY_END());
+}
+
+void loop() {}
+}
@@ -200,6 +200,87 @@ static void test_applyModemConfig_customCodingRateLowerThanPreset()
    TEST_ASSERT_EQUAL_UINT8(8, testRadio->getCr());
 }

+// -----------------------------------------------------------------------
+// getRegionPresetMap() — region->valid-preset map sent to clients during want_config
+// -----------------------------------------------------------------------
+
+static size_t countKnownRegions()
+{
+    size_t n = 0;
+    for (const RegionInfo *r = regions; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET; r++)
+        n++;
+    return n;
+}
+
+// Every region in the firmware table (except the UNSET sentinel) must appear
+// exactly once in the map, and all counts must stay within the mesh.options bounds
+// (exceeding them would mean nanopb silently truncates the wire message).
+static void test_regionPresetMap_coversAllRegionsWithinBounds()
+{
+    meshtastic_LoRaRegionPresetMap map;
+    getRegionPresetMap(map);
+
+    const size_t known = countKnownRegions();
+    TEST_ASSERT_EQUAL_UINT((unsigned)known, (unsigned)map.region_groups_count);
+
+    // Bounds derived from the generated nanopb arrays (mesh.options max_count), so
+    // this stays correct if those bounds change.
+    const size_t maxGroups = sizeof(map.groups) / sizeof(map.groups[0]);
+    const size_t maxRegions = sizeof(map.region_groups) / sizeof(map.region_groups[0]);
+    TEST_ASSERT_GREATER_THAN_UINT(0, map.groups_count);
+    TEST_ASSERT_LESS_OR_EQUAL_UINT((unsigned)maxGroups, map.groups_count);
+    TEST_ASSERT_LESS_OR_EQUAL_UINT((unsigned)maxRegions, map.region_groups_count);
+
+    // Each known region appears exactly once.
+    for (const RegionInfo *r = regions; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET; r++) {
+        int hits = 0;
+        for (pb_size_t i = 0; i < map.region_groups_count; i++)
+            if (map.region_groups[i].region == r->code)
+                hits++;
+        TEST_ASSERT_EQUAL_INT(1, hits);
+    }
+}
+
+// The advertised presets must agree with the live region table: every preset is
+// legal in its region, the default is among them, and the licensed flag matches.
+static void test_regionPresetMap_matchesRegionTable()
+{
+    meshtastic_LoRaRegionPresetMap map;
+    getRegionPresetMap(map);
+
+    for (pb_size_t i = 0; i < map.region_groups_count; i++) {
+        meshtastic_Config_LoRaConfig_RegionCode code = map.region_groups[i].region;
+        uint8_t gi = map.region_groups[i].group_index;
+        TEST_ASSERT_LESS_THAN_UINT(map.groups_count, gi);
+
+        const meshtastic_LoRaPresetGroup &grp = map.groups[gi];
+        const RegionInfo *r = getRegion(code);
+
+        // Group's list is non-empty, within the generated array bound, and is the
+        // region's full list.
+        const size_t maxPresets = sizeof(grp.presets) / sizeof(grp.presets[0]);
+        TEST_ASSERT_GREATER_THAN_UINT(0, grp.presets_count);
+        TEST_ASSERT_LESS_OR_EQUAL_UINT((unsigned)maxPresets, grp.presets_count);
+        TEST_ASSERT_EQUAL_UINT((unsigned)r->getNumPresets(), (unsigned)grp.presets_count);
+
+        // Every advertised preset is legal in this region.
+        for (pb_size_t p = 0; p < grp.presets_count; p++)
+            TEST_ASSERT_TRUE(r->supportsPreset(grp.presets[p]));
+
+        // Default preset matches the table, is legal, and is present in the list.
+        TEST_ASSERT_EQUAL(r->getDefaultPreset(), grp.default_preset);
+        TEST_ASSERT_TRUE(r->supportsPreset(grp.default_preset));
+        bool defaultInList = false;
+        for (pb_size_t p = 0; p < grp.presets_count; p++)
+            if (grp.presets[p] == grp.default_preset)
+                defaultInList = true;
+        TEST_ASSERT_TRUE(defaultInList);
+
+        // Licensed flag matches the region's profile.
+        TEST_ASSERT_EQUAL(r->profile->licensedOnly, grp.licensed_only);
+    }
+}
+
 void setUp(void)
 {
    mockMeshService = new MockMeshService();
@@ -241,6 +322,8 @@ void setup()
    RUN_TEST(test_applyModemConfig_codingRateMatchesPreset);
    RUN_TEST(test_applyModemConfig_customCodingRateHigherThanPreset);
    RUN_TEST(test_applyModemConfig_customCodingRateLowerThanPreset);
+    RUN_TEST(test_regionPresetMap_coversAllRegionsWithinBounds);
+    RUN_TEST(test_regionPresetMap_matchesRegionTable);
    exit(UNITY_END());
 }

@@ -13,8 +13,10 @@

 #if WARM_NODE_COUNT > 0

+#include "FSCommon.h"
 #include "mesh/WarmNodeStore.h"
 #include <cstring>
+#include <vector>

 namespace
 {
@@ -76,12 +78,15 @@ void test_ws_take_removesEntry()
    WarmNodeStore ws;
    uint8_t key[32];
    makeKey(key, 3);
-    ws.absorb(0x400, 1234, key);
+    ws.absorb(0x400, 1234, key, 5 /* TRACKER */, (uint8_t)WarmProtected::Role);

    WarmNodeEntry e;
    TEST_ASSERT_TRUE(ws.take(0x400, e));
    TEST_ASSERT_EQUAL(0x400, e.num);
-    TEST_ASSERT_EQUAL(1234, e.last_heard);
+    // last_heard is quantised to the metadata quantum; role/protected ride the low bits.
+    TEST_ASSERT_EQUAL(1234u & WARM_TIME_MASK, warmTimeOf(e));
+    TEST_ASSERT_EQUAL(5, warmRoleOf(e));
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::Role, warmProtOf(e));
    TEST_ASSERT_EQUAL_MEMORY(key, e.public_key, 32);
    TEST_ASSERT_FALSE(ws.contains(0x400));
    TEST_ASSERT_FALSE(ws.take(0x400, e));
@@ -111,13 +116,15 @@ void test_ws_keyedCandidate_evictsOldestKeylessFirst()
    // Fill with keyed entries except two keyless ones in the middle
    for (size_t i = 0; i < ws.capacity(); i++) {
        const bool keyless = (i == 5 || i == 10);
-        TEST_ASSERT_TRUE(ws.absorb(0x1000 + i, keyless ? (i == 10 ? 50 : 60) : 10, keyless ? NULL : key));
+        // Timestamps spaced by the 64 s warm metadata quantum (<<6) so LRU order survives
+        // quantisation: keyless i=10 is oldest (50), i=5 next (60), keyed all older (10).
+        TEST_ASSERT_TRUE(ws.absorb(0x1000 + i, (keyless ? (i == 10 ? 50u : 60u) : 10u) << 6, keyless ? NULL : key));
    }
    // Keyed candidate must displace the OLDEST KEYLESS entry (0x100A, ts=50),
    // even though every keyed entry is older (ts=10)
    uint8_t k2[32];
    makeKey(k2, 0x43);
-    TEST_ASSERT_TRUE(ws.absorb(0x8888, 70, k2));
+    TEST_ASSERT_TRUE(ws.absorb(0x8888, 70u << 6, k2));
    TEST_ASSERT_FALSE(ws.contains(0x1000 + 10));
    TEST_ASSERT_TRUE(ws.contains(0x1000 + 5));
    TEST_ASSERT_TRUE(ws.contains(0x8888));
@@ -139,6 +146,31 @@ void test_ws_keyedCandidate_evictsOldestKeyedWhenNoKeyless()
    TEST_ASSERT_EQUAL(ws.capacity(), ws.count());
 }

+void test_ws_meta_roundTrip()
+{
+    WarmNodeStore ws;
+    uint8_t key[32];
+    makeKey(key, 0x77);
+    // Keyed TRACKER(5)/Role-protected and keyless SENSOR(6)/unprotected.
+    TEST_ASSERT_TRUE(ws.absorb(0x700, 1234, key, 5 /* TRACKER */, (uint8_t)WarmProtected::Role));
+    TEST_ASSERT_TRUE(ws.absorb(0x701, 5678, NULL, 6 /* SENSOR */, (uint8_t)WarmProtected::None));
+
+    uint8_t role = 0xFF, prot = 0xFF;
+    TEST_ASSERT_TRUE(ws.lookupMeta(0x700, role, prot));
+    TEST_ASSERT_EQUAL(5, role);
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::Role, prot);
+    TEST_ASSERT_TRUE(ws.lookupMeta(0x701, role, prot));
+    TEST_ASSERT_EQUAL(6, role);
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::None, prot);
+    // Absent node yields false and leaves outputs untouched-by-contract (just check return).
+    TEST_ASSERT_FALSE(ws.lookupMeta(0x999, role, prot));
+    // Default args still compile (role/protected = 0 = CLIENT/None).
+    TEST_ASSERT_TRUE(ws.absorb(0x702, 9999, NULL));
+    TEST_ASSERT_TRUE(ws.lookupMeta(0x702, role, prot));
+    TEST_ASSERT_EQUAL(0, role);
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::None, prot);
+}
+
 void test_ws_remove_and_clear()
 {
    WarmNodeStore ws;
@@ -175,6 +207,56 @@ void test_ws_persistence_roundTrip()
    b.saveIfDirty();
 }

+// Migration: a v1 (WRM1) warm.dat must keep identity + key but discard last_heard
+// (so its low bits aren't misread as role/protected). File backend only.
+void test_ws_v1_migration_discardsLastHeard()
+{
+    WarmNodeStore a;
+    uint8_t key[32], got[32];
+    makeKey(key, 0x66);
+    a.absorb(0x900, 123456, key, 5 /* TRACKER */, (uint8_t)WarmProtected::Role);
+    if (!a.saveIfDirty()) {
+        TEST_IGNORE_MESSAGE("Filesystem not available in this test environment");
+        return;
+    }
+
+    // Read the whole v2 file, flip the 4-byte header magic to v1 ("WRM1"), write it back.
+    // (CRC covers only the entry bytes, so patching the header magic keeps it valid.)
+    std::vector<uint8_t> buf;
+    {
+        auto f = FSCom.open("/prefs/warm.dat", FILE_O_READ);
+        if (!f) {
+            TEST_IGNORE_MESSAGE("warm.dat not readable in this environment");
+            return;
+        }
+        buf.resize(f.size());
+        f.read(buf.data(), buf.size());
+        f.close();
+    }
+    TEST_ASSERT_TRUE(buf.size() >= 4);
+    const uint32_t v1magic = 0x314D5257u; // "WRM1"
+    memcpy(buf.data(), &v1magic, sizeof(v1magic));
+    {
+        auto f = FSCom.open("/prefs/warm.dat", FILE_O_WRITE);
+        TEST_ASSERT_TRUE((bool)f);
+        f.write(buf.data(), buf.size());
+        f.close();
+    }
+
+    WarmNodeStore b;
+    b.load();
+    TEST_ASSERT_TRUE(b.contains(0x900));     // identity survived migration
+    TEST_ASSERT_TRUE(b.copyKey(0x900, got)); // public key survived
+    TEST_ASSERT_EQUAL_MEMORY(key, got, 32);
+    uint8_t role = 0xFF, prot = 0xFF;
+    TEST_ASSERT_TRUE(b.lookupMeta(0x900, role, prot));
+    TEST_ASSERT_EQUAL(0, role); // last_heard discarded → role/protected reset
+    TEST_ASSERT_EQUAL((uint8_t)WarmProtected::None, prot);
+
+    b.clear();
+    b.saveIfDirty();
+}
+
 WS_TEST_ENTRY void setup()
 {
    initializeTestEnvironment();
@@ -187,8 +269,10 @@ WS_TEST_ENTRY void setup()
    RUN_TEST(test_ws_keylessCandidate_neverEvictsKeyedEntries);
    RUN_TEST(test_ws_keyedCandidate_evictsOldestKeylessFirst);
    RUN_TEST(test_ws_keyedCandidate_evictsOldestKeyedWhenNoKeyless);
+    RUN_TEST(test_ws_meta_roundTrip);
    RUN_TEST(test_ws_remove_and_clear);
    RUN_TEST(test_ws_persistence_roundTrip);
+    RUN_TEST(test_ws_v1_migration_discardsLastHeard);
    exit(UNITY_END());
 }

@@ -24,6 +24,7 @@
  // "USERPREFS_CONFIG_OWNER_SHORT_NAME": "MLN",
  // "USERPREFS_CONFIG_DEVICE_ROLE": "meshtastic_Config_DeviceConfig_Role_CLIENT", // Defaults to CLIENT. ROUTER*, and LOST AND FOUND roles are restricted.
  // "USERPREFS_EVENT_MODE": "1",
+  // "USERPREFS_TMM_APPLY_TO_PRIVATE_CHANNELS": "1", // Extend TMM position dedup and precision clamping to private/custom-key channels (default: well-known channels only)
  // "USERPREFS_FIRMWARE_EDITION": "meshtastic_FirmwareEdition_BURNING_MAN",
  // "USERPREFS_FIXED_BLUETOOTH": "121212",
  // "USERPREFS_FIXED_GPS": "",
@@ -276,9 +276,23 @@ custom_sdkconfig =
  CONFIG_BT_NIMBLE_ROLE_CENTRAL=n
  CONFIG_BT_NIMBLE_ROLE_OBSERVER=n
  CONFIG_BT_CONTROLLER_ENABLED=y
-  CONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
-  CONFIG_BT_NIMBLE_MAX_CCCDS=20
+  # BLE RAM right-sizing for a single-phone peripheral. IDF-5.5/Arduino-3.x raised RAM use to where
+  # NimBLE bring-up no longer had enough contiguous heap (host task fails to allocate -> host never
+  # syncs -> BLEDevice::init() hangs; GATT/advertising then OOM). The node only ever has one
+  # connection and never scans, so trimming these over-provisioned controller/host buffers frees
+  # the heap. Keep the host-task stack at the IDF default 5120 (do NOT lower to 4096 -- #2618 raised
+  # it because 4096 overflows); the prior 8192 was an over-allocation that starved advertising.
+  CONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=5120
+  CONFIG_BT_NIMBLE_MAX_CCCDS=8
  CONFIG_BT_NIMBLE_MAX_BONDS=6
+  CONFIG_BT_NIMBLE_MAX_CONNECTIONS=1
+  CONFIG_BT_CTRL_BLE_MAX_ACT=2
+  CONFIG_BT_CTRL_SCAN_DUPL_CACHE_SIZE=10
+  CONFIG_BT_NIMBLE_WHITELIST_SIZE=1
+  CONFIG_BT_NIMBLE_MSYS_1_BLOCK_COUNT=8
+  CONFIG_BT_NIMBLE_MSYS_2_BLOCK_COUNT=8
+  CONFIG_BT_NIMBLE_TRANSPORT_ACL_FROM_LL_COUNT=8
+  CONFIG_BT_NIMBLE_TRANSPORT_EVT_COUNT=12
  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_SYNC=n
  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_ADV=n
  CONFIG_BT_NIMBLE_EXT_SCAN=n
@@ -33,9 +33,6 @@
 #ifndef HAS_TRAFFIC_MANAGEMENT
 #define HAS_TRAFFIC_MANAGEMENT 1
 #endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif

 // ---- GC1109 RF FRONT END CONFIGURATION ----
 // The Heltec V4.2 uses a GC1109 FEM chip with integrated PA and LNA
@@ -31,9 +31,6 @@
 #ifndef HAS_TRAFFIC_MANAGEMENT
 #define HAS_TRAFFIC_MANAGEMENT 1
 #endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif

 // ---- KCT8103L RF FRONT END CONFIGURATION ----
 // The Heltec V4.3 uses a KCT8103L FEM chip with integrated PA and LNA
@@ -19,14 +19,14 @@ custom_meshtastic_support_level = 1
 custom_meshtastic_display_name = RAK WisMesh Tap V2
 custom_meshtastic_images = rak-wismesh-tap-v2.svg
 custom_meshtastic_tags = RAK
-custom_meshtastic_partition_scheme = 8MB
+custom_meshtastic_partition_scheme = 16MB
 custom_meshtastic_has_mui = true

 extends = esp32s3_base
 board = wiscore_rak3312
 board_check = true
 upload_protocol = esptool
-board_build.partitions = default_8MB.csv
+board_build.partitions = default_16MB.csv

 build_flags = 
  ${esp32s3_base.build_flags}
@@ -53,6 +53,7 @@
 #define BATTERY_PIN 1
 #define ADC_CHANNEL ADC_CHANNEL_0
 #define ADC_MULTIPLIER 1.667
+#define OCV_ARRAY 4160, 4020, 3940, 3870, 3810, 3760, 3740, 3720, 3680, 3620, 2990

 #define PIN_BUZZER 38

@@ -14,9 +14,6 @@ Board Information: https://wiki.uniteng.com/en/meshtastic/station-g2
 #ifndef HAS_TRAFFIC_MANAGEMENT
 #define HAS_TRAFFIC_MANAGEMENT 1
 #endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif

 /*
 #define BATTERY_PIN 4 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
@@ -2,7 +2,7 @@
 [portduino_base]
 platform =
  # renovate: datasource=git-refs depName=platform-native packageName=https://github.com/meshtastic/platform-native gitBranch=develop
-  https://github.com/meshtastic/platform-native/archive/cab4b21d902973e43c938dab3cf4844ba02547ec.zip
+  https://github.com/meshtastic/platform-native/archive/61067ac3774e4fe27aa9762c72cebea507f116c8.zip
 framework = arduino

 build_src_filter = 
@@ -16,6 +16,3 @@
 #ifndef HAS_VARIABLE_HOPS
 #define HAS_VARIABLE_HOPS 1
 #endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif
Author	SHA1	Message	Date
Jonathan BennettandGitHub	7f0bdb7515	Merge branch 'develop' into serialHal	2026-06-22 16:16:32 -05:00
Thomas GöttgensandGitHub	c4fdf374e1	fix: right-size warm tier for constrained platforms (#10746 , #10705 ) (#10759 ) * fix: right-size warm tier for constrained platforms and feed RP2040 watchdog during NodeDB save * fix: size warm tier and traffic cache per-MCU RAM, lowering no-PSRAM ESP32 (classic/S2/C3) tiers * docs: document nRF52/RP2040 #else fall-through in warm tier and TM cache cascades	2026-06-22 06:21:50 -05:00
Carlos Valdes GitHub Ben Meadors Copilot Autofix powered by AI	3501f620a3	fix: restore fixed position into localPosition on boot (#10670 ) * NodeDB: restore fixed position into localPosition at boot Fixed-position nodes without a GPS stop broadcasting their position (and publishing MQTT map reports) after a reboot. On boot localPosition is empty, and NodeDB::hasValidPosition() for the local node only inspects localPosition, not the persisted node position. PositionModule therefore never sends a position, so the lazy localPosition backfill in getPositionPacket() never runs and localPosition stays at (0,0) indefinitely. Restore the configured fixed position into localPosition during NodeDB construction so position broadcasts and map reports resume automatically after a reboot. * Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Ben Meadors <benmmeadors@gmail.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-06-21 08:17:09 -05:00
Tom GitHub Claude Sonnet 4.6	c51c01607d	Traffic Management module: dedup, rate limiting, role-aware policing (#10706 ) Adds the Traffic Management module (TMM) plus the NodeDB/warm-store and next-hop foundations it builds on: - Unified per-node cache (flat array, 8-bit relative ticks) shared by all features; role-aware throttles for tracker / lost-and-found. - Position deduplication: drop unchanged position rebroadcasts within a configurable interval; precision driven off the channel ceiling (clamped to the public-key max on well-known channels). Enabled by default at 11h. - Per-node rate limiting and unknown-packet filtering (config-driven; a non-zero companion field enables each feature -- no bool toggles). - NodeInfo direct response from cache with role-based hop clamps. - Persistent next-hop overflow store: confirmed hops have no TTL, are seeded from NodeInfoLite at boot, and survive hot-store eviction. - Three-tier sender-role resolution (hot NodeInfoLite -> warm store -> TMM cache). Role is cached write-time (seeded on first track, refreshed from NodeInfo), pins its cache entry like a next-hop hint, and is evicted last. - Warm store caches device role + protected category across reboot/eviction. - PositionModule stationary floor for tracker / lost-and-found. - PSRAM gating for warm/satellite/TMM cache sizes; STM32WL excluded. Protobufs: TrafficManagementConfig trimmed to the five uint32 fields actually used; submodule repointed to protobufs develop. Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-20 20:35:14 -05:00
Tom GitHub Claude Sonnet 4.6	d8d92b7b71	Fix/zerohop and hopscale mqtt (#10753 ) * fix for prehopdrop on zerohop packets * hopscaling: exclude MQTT-origin packets from the node histogram The hop-scaling histogram gate only checked transport_mechanism == TRANSPORT_LORA, which excludes packets received from the broker but NOT MQTT-origin packets that a gateway rebroadcasts onto LoRa (those arrive as TRANSPORT_LORA with via_mqtt set). Counting them inflates the local mesh-size/density estimate with nodes that aren't real RF participants — and since the bridged copy usually carries hop_start==0 they land in the hop-0 bucket, the one that pulls getLastRequiredHop() lowest, over- shrinking NodeInfo/position/telemetry hop limits. Add `!mp.via_mqtt` to the gate. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-06-20 17:08:29 -05:00
Ben Meadors	161cd26519	Add conditional compilation for warm node count checks	2026-06-19 20:49:48 -05:00
Ben MeadorsandGitHub	dd1ec9d462	Lora region preset map (#10736 ) * Added lora region and preset maps * Protos * Address PR review feedback - Log (and break/skip) when the region preset map exceeds its array bounds instead of silently dropping regions - Derive test bounds from the generated nanopb array sizes via sizeof() instead of hard-coded magic numbers - Fix want_config sequence comment (missing comma, STATE_SEND_MODULECONFIG) - Specify a language on the spec's fenced code blocks (markdownlint MD040) * Fix want_config stall: handle STATE_SEND_REGION_PRESETS in PhoneAPI::available() available() had a separate per-state switch that wasn't updated for the new state, so it returned false ('unexpected state 5') and getFromRadio() was never called - the config handshake stalled after metadata and the client timed out. Verified via the native simulator integration test.	2026-06-19 19:56:24 -05:00
Tom GitHub Claude Opus 4.8 Ben Meadors	22072c5f4b	Pr1.5 tmm nexthop (#10745 ) * TrafficManagement: flat unified cache + persistent next-hop overflow store Reworks the TrafficManagementModule cache layer (policing behaviour unchanged from upstream) and adds a routing-hint overflow store: - Flatten the ring: replace the cuckoo-hashed unified cache and the bucketed PSRAM NodeInfo index with plain flat arrays + linear scan (same idiom as WarmNodeStore). At LoRa packet rates an O(n) scan of the cache is negligible, and it removes a large amount of hashing/displacement complexity. The cache entry is 11 B; timestamps use a uniform +1 presence-offset so a 0 byte always means "empty" across every sub-store. Adds rebaseEpoch() so cached state survives the ~19 h relative-timestamp horizon instead of being flushed. - Next-hop overflow cache: setNextHop/getNextHopHint store a confirmed last-byte relay for a destination, written only from NextHopRouter's ACK-confirmed decision (and mirrored from TraceRoute). NextHopRouter::getNextHop falls back to this cache when the hot NodeDB has no hint, so DMs/relays to long-tail nodes keep routing after the node ages out of NodeInfoLite. - Persistence: preloadNextHopsFromNodeDB warm-starts the cache from persisted NodeInfoLite hints on first maintenance pass; next_hop entries are kept alive across the maintenance sweep (no TTL) and never clobbered by a stale preload. All packet-policing logic (rate limit, position dedup, unknown-packet drop, NodeInfo direct response, hop exhaustion) is the existing upstream behaviour, untouched. HAS_TRAFFIC_MANAGEMENT defaults on so the module is compiled in. (see note). Tests: upstream policing suite now actually runs (adds the MeshTypes.h include that gates HAS_TRAFFIC_MANAGEMENT) plus 4 next-hop tests. Role-aware throttles, politeness, precision clamp, port-interval and mesh-radius gating — and the rate-limit >255 saturation fix — are deferred to the advanced-TMM branch. Note: default dedup movement grid moves to ~91m, which also means 1.5km required to end up with the same signature position - coarser and therefore further than before. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * TrafficManagement: fix cppcheck constVariablePointer warning `node` in preloadNextHopsFromNodeDB() is never written through — mark it const to satisfy cppcheck's constVariablePointer check in CI. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * Add multi-hop NextHop recovery tests and unit tests for routing reliability - Introduced a new test suite for multi-hop NextHop directed-message delivery and relay recovery in `test_nexthop_multihop_recovery.py`. This includes tests for end-to-end delivery and recovery after relay drop. - Implemented unit tests in `test_main.cpp` for NextHop routing reliability mitigations, covering: - M1: Ambiguity-aware last-byte resolution. - M2: NextHopRouter's strict-neighbor gate and hop limit checks. - M3: Route-health freshness and failure decay. - Enhanced mock classes to facilitate controlled testing of node behaviors and routing logic. * grafting fixed * Address Copilot review for PR #10735 (NextHop improvements) - docs/nexthop-routing-reliability.md: update status from "no code changes yet" to reflect that mitigations and tests are implemented RAM pressure and MIGRATION_VERBOSE concerns addressed upstream in PR2.5 (per-platform TRAFFIC_MANAGEMENT_CACHE_SIZE) and PR2 (verbose default=0) respectively; (0,0) sentinel fixed in PR2.5. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * CI: fix cppcheck constVariablePointer and test include path - NextHopRouter.cpp: qualify two RouteHealth h locals as const — only read for stale-route checks, never mutated through the pointer - Router.cpp: qualify meshtastic_NodeInfoLite node as const in shouldDecrementHopLimit — only read for favorite/role predicate - test_position_module/test_main.cpp: change bare PositionModule.h to modules/PositionModule.h — build_flags sets -Isrc, not -Isrc/modules, so the bare form fails to resolve in the native PlatformIO test env Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * WarmStore: cache device role + protected category in last_heard low bits Steal the low 6 bits of WarmNodeEntry.last_heard to carry an evicted node's device role (4 bits) and a protected category (2 bits) for the hop-trim path, at zero record-size cost (entry stays 40 B; no RAM/flash growth). The high bits remain a real unix-seconds timestamp, quantised to 64 s — ample for warm LRU ordering of long-tail nodes. - absorb() packs role/protectedCat; place()/ring replay store the raw word so metadata round-trips through flash. LRU compares masked time (warmTimeOf). - take() rehydration masks the metadata bits and restores the cached role so a re-admitted node isn't stuck at CLIENT until its next NodeInfo. - NodeDB classifies the category (favorite/ignored/verified -> Flag; tracker/sensor/tak_tracker -> Role) at each eviction site. - WarmNodeStore::lookupMeta() exposes role/category to consumers. - Bump WARM_RING_MAGIC (WRNG->WRN2): old rings read as erased and rebuild; warm data is a non-critical evictee cache, so discard-on-upgrade is safe. Tests: test_warm_store 11/11 (new meta round-trip + quantisation-aware ordering); NodeDB compiles (test_nodedb_blocked 4/4). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * WarmStore: migrate v1 rings/files by discarding last_heard, not the data Previously the WRNG->WRN2 magic bump treated old rings as erased, discarding all warm entries — including the PKI public keys that let evicted nodes keep decrypting DMs. Instead, read v1 (WRNG / WRM1) records and keep each node's identity + public key, discarding only last_heard (its low bits would otherwise be misread as the new role/protected metadata). Records re-rank and re-learn their role on next contact. - Ring backend (nRF52840): ringReadHeader accepts both magics and reports v1 via an out-param; replay zeroes last_heard for v1 records. If the active head page is v1, force a rotation so new v2 records never land in a v1-headered page (which would discard their freshly-set role on the next load). Legacy pages convert to v2 as the ring rotates. - File backend (warm.dat): bump WARM_STORE_MAGIC WRM1->WRM2; accept WRM1, verify CRC against the stored bytes, then discard last_heard and mark dirty so the next save rewrites as v2. Tests: test_warm_store 12/12 (adds test_ws_v1_migration_discardsLastHeard: key survives, role/protected reset). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * WarmStore: guard role bit-width + test eviction carries role/protected - static_assert that the device role enum still fits the 4-bit warm metadata field (WARM_ROLE_MASK); fails the build loudly if a new role is added past 15 rather than silently truncating role on eviction. (Max role today = 12.) - Add test_migration_carriesRoleAndProtectedIntoWarm: a demoted TRACKER lands in the warm tier with its key, role=TRACKER and protected category=Role; a demoted CLIENT carries role=CLIENT/None. Exercises the NodeDB eviction path + warmProtectedCategory classification (the warm-store unit tests only cover absorb() directly). Tests: test_nodedb_blocked 5/5. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix copilot comments * fix(test): restore #if HAS_TRAFFIC_MANAGEMENT guard in TMM test The rebase onto PR1.5 lost the top-level HAS_TRAFFIC_MANAGEMENT guard that PR1.5 introduced, leaving the #else/#endif tail orphaned and causing compile errors on non-TMM builds. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-06-19 19:52:58 -05:00
Jonathan BennettandGitHub	ca7d82629d	Native sensors (#10748 ) * Enable Sensirion libraries on native * Bump platform-native to get bug fix	2026-06-19 15:50:31 -05:00
Ben Meadors GitHub Copilot Autofix powered by AI	f2f23f8978	NimBLE params overhaul and try-fix for incompatible bond cleanup (#10741 ) * NimBLE params overhaul and try-fix for incompatible bond cleanup * Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * Address PR review: remove dead clearNVS(), defer bond-purge log below init - Delete unused clearNVS() (no callers; should have been removed in #10264). - Move purgeIncompatibleBleBonds() after the "Init the NimBLE" log so bond-cleanup output doesn't appear to precede module init; it still runs before BLEDevice::init() reads the store. * Update MAX_SATELLITE_NODES and WARM_NODE_COUNT definitions for ESP32-S3 PSRAM support --------- Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-06-19 12:21:05 -05:00
Ethac.chen GitHub Cursor Ben Meadors	9358b2c549	fix(esp32): skip RTC timer wake on user shutdown; TAP V2 OCV and partition (#10739 ) * fix(esp32): skip RTC timer wake on user shutdown Do not arm esp_sleep_enable_timer_wakeup when msecToWake is portMAX_DELAY (UI shutdown), matching nRF52 system_off semantics. fix(rak_wismesh_tap_v2): Tag OCV curve and 16MB partition Add OCV_ARRAY matching WisMesh Tag for accurate SOC. Use 16MB flash partition scheme for TAP V2 hardware. Co-authored-by: Cursor <cursoragent@cursor.com> * Trunkt --------- Co-authored-by: Cursor <cursoragent@cursor.com> Co-authored-by: Ben Meadors <benmmeadors@gmail.com>	2026-06-18 16:29:54 -05:00
Jonathan Bennett	0c6753002a	termios raw mode to avoid byte mangling	2026-05-24 19:05:42 -05:00
Jonathan BennettandGitHub	7555242661	Merge branch 'develop' into serialHal	2026-05-04 22:10:48 -05:00
Jonathan BennettandGitHub	c5a8fbc157	Merge branch 'develop' into serialHal	2026-05-04 13:09:22 -05:00
Jonathan Bennett	fbccf910d4	and fix it on esp32 again	2026-04-30 16:03:35 -05:00
Jonathan Bennett	b02193f341	Compile on 2040	2026-04-30 15:45:36 -05:00
Jonathan Bennett	097f77cbcf	Seitch to concurrency over std::mutex for platform agnostic behavior	2026-04-30 15:21:42 -05:00
Jonathan BennettandGitHub	8995a68b07	Merge branch 'develop' into serialHal	2026-04-30 10:54:42 -05:00
Ben MeadorsandGitHub	ebe6ddc7aa	Merge branch 'develop' into serialHal	2026-04-30 06:12:30 -05:00
Jonathan BennettandGitHub	b27f80131a	Merge branch 'develop' into serialHal	2026-04-30 00:44:52 -05:00
Jonathan Bennett	e3d68645c1	Initial implementation of serialHal	2026-04-30 00:37:00 -05:00