diff --git a/docs/cli_commands.md b/docs/cli_commands.md
index 6f2ac346..ee4a4216 100644
--- a/docs/cli_commands.md
+++ b/docs/cli_commands.md
@@ -28,25 +28,12 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 **Usage:** 
 - `reboot`
 
-**Note:** No reply is sent.
-
----
-
-### Power-off the node
-**Usage:**
-- `poweroff`, or
-- `shutdown`
-
-**Note:** No reply is sent.
-
 ---
 
 ### Reset the clock and reboot
 **Usage:**
 - `clkreboot`
 
-**Note:** No reply is sent.
-
 ---
 
 ### Sync the clock with the remote device
@@ -232,20 +219,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 
 ---
 
-#### View or change the boosted receive gain mode
-**Usage:**
-- `get radio.rxgain`
-- `set radio.rxgain <state>`
-
-**Parameters:**
-- `state`: `on`|`off`
-
-**Default:** `off`
-
-**Note:** Only available on SX1262 and SX1268 based boards.
-
----
-
 #### Change the radio parameters for a set duration
 **Usage:** 
 - `tempradio <freq>,<bw>,<sf>,<cr>,<timeout_mins>`
@@ -458,18 +431,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 
 ---
 
-#### View or set reboot interval (Repeater and room server)
-**Usage:**
-- `get reboot.interval`
-- `set reboot.interval <hours>`
-
-**Parameters:** 
-- `hours`: 0-255. 0 is disabled
-
-**Default:** `0` (disabled)
-
----
-
 ### Routing
 
 #### View or change this node's repeat flag
@@ -699,7 +660,7 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 **Parameters:**
 - `value`: Maximum flood hop count (0-64) for a packet without a scope (no region set)
 
-**Default:** `64` - (`0xFF` indicates it hasn't been set, will track flood.max until it is.)
+**Default:** `0xFF` - indicates it hasn't been set, will track flood.max until it is.
 
 **Note:** An alternative to `region denyf *`, setting `flood.max.unscoped` to a lower value such as `3` would allow for local unscoped messages to propagate, while preventing noisy neighbors from flooding a local region.
 
@@ -830,27 +791,6 @@ This document provides an overview of CLI commands that can be sent to MeshCore
 
 ---
 
-#### View or set the direct path override for the current remote client
-**Usage:**
-- `get outpath`
-- `set outpath <hop1_hex,hop2_hex,...>`
-- `set outpath direct`
-- `set outpath clear`
-- `set outpath flood`
-
-**Parameters:**
-- `hopN_hex`: Hop hash, `2`, `4`, or `6` hex characters. All hops must use the same width.
-
-**Notes:**
-- These commands require remote client context (they target the caller's ACL entry).
-- The path hash size is inferred from the hop hash width.
-- `outpath` overrides the primary direct route used for replies to the caller.
-- `direct` sets a zero-hop direct route for a caller reachable without repeaters.
-- `clear` forgets the current direct path and allows normal path discovery to repopulate it.
-- `flood` forces replies to use flood packets until the client logs in again.
-
----
-
 #### Create a new region
 **Usage:** 
 - `region put <name> [parent_name]`
@@ -1021,6 +961,247 @@ region save
 - Enables flooding for all child regions automatically
 - Useful for global networks with specific regional rules
 
+---
+### Direct Retry
+
+Direct retry resends direct-routed packets when the downstream echo is not heard. It applies to direct messages, ACK packets, multipart packets carrying ACK payloads, and TRACE packets.
+
+#### View or change direct retry state
+**Usage:**
+- `get direct.retry`
+- `set direct.retry <state>`
+
+**Parameters:**
+- `state`: `on`|`off`
+
+**Default:** `on`
+
+**Notes:**
+- New installs and older preference files without direct retry settings default to `on` with the `rooftop` preset.
+
+**Examples:**
+```
+get direct.retry
+set direct.retry on
+set direct.retry off
+```
+
+---
+
+#### View or apply a direct retry preset
+**Usage:**
+- `get retry.preset`
+- `set retry.preset <preset>`
+
+**Parameters:**
+- `preset`: `infra`|`rooftop`|`mobile`
+
+**Notes:**
+- `infra`: fewer, slower retries for stable fixed infrastructure.
+- `rooftop`: default long retry window for weak rooftop links.
+- `mobile`: long retry count with shorter spacing for moving or changing links.
+- Changing `direct.retry.count`, `direct.retry.base`, `direct.retry.step`, or `direct.retry.margin` makes the preset report as `custom`.
+
+**Examples:**
+```
+get retry.preset
+set retry.preset infra
+set retry.preset rooftop
+set retry.preset mobile
+```
+
+---
+
+#### View or change direct retry count
+**Usage:**
+- `get direct.retry.count`
+- `set direct.retry.count <count>`
+
+**Parameters:**
+- `count`: Maximum retry attempts after the original send, from `1` to `15`.
+
+**Default:** `15` with the `rooftop` preset
+
+**Examples:**
+```
+get direct.retry.count
+set direct.retry.count 1
+set direct.retry.count 4
+set direct.retry.count 15
+```
+
+---
+
+#### View or change direct retry base delay
+**Usage:**
+- `get direct.retry.base`
+- `set direct.retry.base <ms>`
+
+**Parameters:**
+- `ms`: First retry wait in milliseconds, from `10` to `5000`.
+
+**Default:** `175` with the `rooftop` preset
+
+**Explanation:**
+- The first retry waits `base` milliseconds after the failed echo window.
+- Larger values reduce channel pressure and give slow repeaters more time.
+- Smaller values recover faster but create tighter retry bursts.
+
+**Examples:**
+```
+get direct.retry.base
+set direct.retry.base 175
+set direct.retry.base 275
+set direct.retry.base 500
+```
+
+---
+
+#### View or change direct retry step delay
+**Usage:**
+- `get direct.retry.step`
+- `set direct.retry.step <ms>`
+
+**Parameters:**
+- `ms`: Extra milliseconds added for each subsequent retry, from `0` to `5000`.
+
+**Default:** `100` with the `rooftop` preset
+
+**Explanation:**
+- Retry delay is `base + attempt_index * step`.
+- With `base=175` and `step=100`, retries wait about `175`, `275`, `375`, `475` ms, and so on.
+- `step=0` keeps every retry at the same delay.
+- Larger steps spread retries over time and are safer on busy channels.
+
+**Examples:**
+```
+get direct.retry.step
+set direct.retry.step 0
+set direct.retry.step 50
+set direct.retry.step 100
+set direct.retry.step 250
+```
+
+---
+
+#### View or change direct retry SNR margin
+**Usage:**
+- `get direct.retry.margin`
+- `set direct.retry.margin <snr_db>`
+
+**Parameters:**
+- `snr_db`: Extra SNR margin above the SF receive floor, from `0` to `40`.
+
+**Default:** `5.00` with the `rooftop` preset
+
+**Notes:**
+- Unknown repeaters are still retried.
+- Known repeaters below the receive floor plus this margin are skipped.
+- Failed attempts lower the recent repeater SNR estimate by `0.25 dB`.
+
+**Examples:**
+```
+get direct.retry.margin
+set direct.retry.margin 0
+set direct.retry.margin 2.5
+set direct.retry.margin 5
+set direct.retry.margin 10
+```
+
+---
+
+#### View or change adaptive direct retry coding rate
+**Usage:**
+- `get direct.retry.cr`
+- `set direct.retry.cr off`
+- `set direct.retry.cr <cr4_min>,<cr5_min>,<cr7_min>,<cr8_max>`
+
+**Parameters:**
+- `cr4_min`: Minimum SNR in dB to retry at CR4.
+- `cr5_min`: Minimum SNR in dB to retry at CR5.
+- `cr7_min`: Minimum SNR in dB to retry at CR7.
+- `cr8_max`: Maximum SNR in dB that forces CR8.
+
+**Default:** `10.00,7.50,2.50,2.50`
+
+**Explanation:**
+- Higher SNR uses faster coding rates.
+- Lower SNR uses more robust coding rates.
+- CR6 is intentionally skipped.
+- `off` disables per-packet retry CR overrides and uses the current radio CR.
+- Direct path retry packets sent at CR4 or CR5 temporarily use a shorter 16-symbol preamble, then restore the radio's default preamble.
+- Unknown repeaters start at `+3.00 dB` for adaptive CR selection.
+- A failed unknown repeater is seeded at `+2.75 dB`.
+- Each later failure lowers the SNR estimate by `0.25 dB`.
+
+**Examples:**
+```
+get direct.retry.cr
+set direct.retry.cr off
+set direct.retry.cr 10.0,7.5,2.5,2.5
+set direct.retry.cr 12.0,8.0,4.0,1.0
+set direct.retry.cr 8.0,5.0,1.5,0
+set direct.retry.cr 6.0,3.0,0,-2.0
+set direct.retry.cr 20.0,12.0,6.0,2.0
+set direct.retry.cr 4.0,2.0,0,-4.0
+```
+
+**Example profiles:**
+- Conservative weak-link profile:
+```
+set direct.retry.cr 12.0,8.0,4.0,1.0
+```
+- Balanced rooftop profile:
+```
+set direct.retry.cr 10.0,7.5,2.5,2.5
+```
+- Faster strong-link profile:
+```
+set direct.retry.cr 6.0,3.0,0,-2.0
+```
+- Very cautious noisy-link profile:
+```
+set direct.retry.cr 20.0,12.0,6.0,2.0
+```
+
+---
+
+#### View, seed, or clear the recent repeater table
+**Usage:**
+- `get recent.repeater`
+- `get recent.repeater <page>`
+- `set recent.repeater <prefix> [snr_db]`
+- `clear recent.repeater`
+
+**Parameters:**
+- `prefix`: Repeater path-hash prefix as hex.
+- `snr_db`: Optional SNR in dB. If omitted or invalid, defaults to `3.0`.
+- `page`: 1-based result page.
+
+**Output order:**
+- `get recent.repeater` lists 3-byte prefixes first, then 2-byte prefixes, then 1-byte prefixes.
+- Within each prefix length, entries are sorted from highest SNR to lowest SNR.
+
+**SNR details:**
+- Recent repeater SNR is stored internally in quarter-dB units.
+- Heard repeater samples update an existing table entry with a weighted blend: `75%` existing SNR and `25%` new heard SNR, rounded up.
+- Direct retry success also feeds the heard echo SNR back into the same weighted table.
+- Direct retry failure is not weighted: each final echo-timeout failure lowers that repeater's SNR by `0.25 dB`.
+- Unknown repeaters start at `+3.00 dB` for adaptive CR selection.
+- If an unknown repeater fails, it is seeded into the table at `+2.75 dB`.
+- `set recent.repeater <prefix> [snr_db]` seeds a missing prefix or adds another weighted sample for an existing prefix.
+- Successful `set recent.repeater` replies include the stored prefix and SNR, for example `OK - set A1B2C3 at 3.0 SNR`.
+
+**Examples:**
+```
+get recent.repeater
+get recent.repeater 2
+set recent.repeater A1B2C3 8.5
+set recent.repeater 71CE82 -3.25
+set recent.repeater A1B2C3
+clear recent.repeater
+```
+
 ---
 ### GPS (When GPS support is compiled in)
 
diff --git a/examples/simple_repeater/MyMesh.cpp b/examples/simple_repeater/MyMesh.cpp
index 68cc3685..2641b20d 100644
--- a/examples/simple_repeater/MyMesh.cpp
+++ b/examples/simple_repeater/MyMesh.cpp
@@ -549,6 +549,203 @@ uint32_t MyMesh::getDirectRetransmitDelay(const mesh::Packet *packet) {
   return getRNG()->nextInt(0, 5*t + 1);
 }
 
+bool MyMesh::extractDirectRetryPrefix(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const {
+  if (packet == NULL || !packet->isRouteDirect() || packet->getPathHashCount() == 0) {
+    return false;
+  }
+  prefix_len = packet->getPathHashSize();
+  memcpy(prefix, packet->path, prefix_len);
+  return true;
+}
+
+int8_t MyMesh::getDirectRetryMinSNRX4() const {
+  switch (active_sf) {
+    case 7: return -30;
+    case 8: return -40;
+    case 9: return -50;
+    case 10: return -60;
+    case 11: return -70;
+    case 12: return -80;
+    default: return -60;
+  }
+}
+
+uint8_t MyMesh::getDirectRetryCodingRateForSNR(int8_t snr_x4) const {
+  if (!_prefs.direct_retry_cr_enabled) return 0;
+  if (snr_x4 >= _prefs.direct_retry_cr4_snr_x4) return 4;
+  if (snr_x4 >= _prefs.direct_retry_cr5_snr_x4) return 5;
+  if (snr_x4 <= _prefs.direct_retry_cr8_snr_x4) return 8;
+  if (snr_x4 >= _prefs.direct_retry_cr7_snr_x4) return 7;
+  return 7;
+}
+
+uint8_t MyMesh::getDirectRetryConfiguredMaxAttempts() const {
+  return constrain(_prefs.direct_retry_attempts, 1, 15);
+}
+
+uint32_t MyMesh::getDirectRetryAttemptStepMillis() const {
+  return _prefs.direct_retry_step_ms;
+}
+
+bool MyMesh::allowDirectRetry(const mesh::Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const {
+  (void)packet;
+  if (!_prefs.direct_retry_enabled) {
+    return false;
+  }
+  if (next_hop_hash == NULL || next_hop_hash_len == 0) {
+    return true;
+  }
+  const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
+  const SimpleMeshTables::RecentRepeaterInfo* repeater = tables != NULL
+      ? tables->findRecentRepeaterByHash(next_hop_hash, next_hop_hash_len)
+      : NULL;
+
+  if (repeater == NULL) {
+    // Retry unknown repeaters too. If they fail, onDirectRetryFailed() seeds the
+    // recent-repeater table below the +3.00 dB starting point.
+    return true;
+  }
+  int16_t retry_floor_x4 = (int16_t)getDirectRetryMinSNRX4() + (int16_t)_prefs.direct_retry_snr_margin_x4;
+  return (int16_t)repeater->snr_x4 >= retry_floor_x4;
+}
+
+void MyMesh::configureDirectRetryPacket(mesh::Packet* retry, const mesh::Packet* original, uint8_t retry_attempt) {
+  (void)retry_attempt;
+  int8_t snr_x4 = 12;  // unknown repeaters start at +3.00 dB
+  const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
+  if (tables != NULL) {
+    uint8_t prefix[MAX_HASH_SIZE];
+    uint8_t prefix_len = 0;
+    if (extractDirectRetryPrefix(original, prefix, prefix_len)) {
+      const SimpleMeshTables::RecentRepeaterInfo* repeater = tables->findRecentRepeaterByHash(prefix, prefix_len);
+      if (repeater != NULL) {
+        snr_x4 = repeater->snr_x4;
+      }
+    }
+  }
+
+  retry->tx_cr = getDirectRetryCodingRateForSNR(snr_x4);
+}
+
+uint32_t MyMesh::getDirectRetryEchoDelay(const mesh::Packet* packet) const {
+  (void)packet;
+  return 200;
+}
+
+uint8_t MyMesh::getDirectRetryMaxAttempts(const mesh::Packet* packet) const {
+  (void)packet;
+  return getDirectRetryConfiguredMaxAttempts();
+}
+
+uint32_t MyMesh::getDirectRetryAttemptDelay(const mesh::Packet* packet, uint8_t attempt_idx) {
+  (void)packet;
+  return _prefs.direct_retry_base_ms + ((uint32_t)attempt_idx * getDirectRetryAttemptStepMillis());
+}
+
+void MyMesh::onDirectRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) {
+#if MESH_DEBUG
+  MESH_DEBUG_PRINTLN("direct retry %s attempt=%u delay=%lu type=%u route=%s",
+                     event ? event : "?",
+                     (uint32_t)retry_attempt,
+                     (unsigned long)delay_millis,
+                     packet ? (uint32_t)packet->getPayloadType() : 0,
+                     packet && packet->isRouteDirect() ? "D" : "F");
+#endif
+  if (_logging) {
+    File f = openAppend(PACKET_LOG_FILE);
+    if (f) {
+      f.print(getLogDateTime());
+      f.printf(": direct retry %s attempt=%u delay=%lu type=%u route=%s\n",
+               event ? event : "?",
+               (uint32_t)retry_attempt,
+               (unsigned long)delay_millis,
+               packet ? (uint32_t)packet->getPayloadType() : 0,
+               packet && packet->isRouteDirect() ? "D" : "F");
+      f.close();
+    }
+  }
+}
+
+void MyMesh::onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) {
+  if (next_hop_hash == NULL || next_hop_hash_len == 0) {
+    return;
+  }
+
+  SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
+  if (tables != NULL) {
+    if (!tables->decrementRecentRepeaterSnrX4(next_hop_hash, next_hop_hash_len, 1)) {
+      tables->setRecentRepeater(next_hop_hash, next_hop_hash_len, 11);
+    }
+  }
+}
+
+void MyMesh::onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) {
+  if (next_hop_hash == NULL || next_hop_hash_len == 0) {
+    return;
+  }
+
+  SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
+  if (tables != NULL) {
+    tables->setRecentRepeater(next_hop_hash, next_hop_hash_len, snr_x4);
+  }
+}
+
+static void formatLocalSnrX4(char* dest, size_t dest_len, int16_t snr_x4) {
+  int16_t v = snr_x4;
+  const char* sign = "";
+  if (v < 0) {
+    sign = "-";
+    v = -v;
+  }
+  snprintf(dest, dest_len, "%s%d.%02d", sign, v / 4, (v % 4) * 25);
+}
+
+void MyMesh::formatRecentRepeatersReply(char *reply, int page) {
+  const SimpleMeshTables* tables = static_cast<const SimpleMeshTables*>(getTables());
+  if (tables == NULL) {
+    strcpy(reply, "Error: unsupported");
+    return;
+  }
+  int count = tables->getRecentRepeaterCount();
+  if (count <= 0) {
+    strcpy(reply, "> -none-");
+    return;
+  }
+
+  const int page_size = 4;
+  int pages = (count + page_size - 1) / page_size;
+  if (page < 1) page = 1;
+  if (page > pages) page = pages;
+
+  int len = snprintf(reply, 160, "> %d/%d ", page, pages);
+  int start = (page - 1) * page_size;
+  for (int i = 0; i < page_size && len < 150; i++) {
+    const SimpleMeshTables::RecentRepeaterInfo* info = tables->getRecentRepeaterBySortedIdx(start + i);
+    if (info == NULL) break;
+    char prefix[MAX_ROUTE_HASH_BYTES * 2 + 1];
+    char snr[12];
+    mesh::Utils::toHex(prefix, info->prefix, info->prefix_len);
+    prefix[info->prefix_len * 2] = 0;
+    formatLocalSnrX4(snr, sizeof(snr), info->snr_x4);
+    len += snprintf(&reply[len], 160 - len, "%s%s,%s",
+                    i == 0 ? "" : " ",
+                    prefix,
+                    snr);
+  }
+}
+
+bool MyMesh::setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
+  SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
+  return tables != NULL && tables->setRecentRepeater(prefix, prefix_len, snr_x4);
+}
+
+void MyMesh::clearRecentRepeaters() {
+  SimpleMeshTables* tables = static_cast<SimpleMeshTables*>(getTables());
+  if (tables != NULL) {
+    tables->clearRecentRepeaters();
+  }
+}
+
 bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
   // just try to determine region for packet (apply later in allowPacketForward())
   if (pkt->getRouteType() == ROUTE_TYPE_TRANSPORT_FLOOD) {
@@ -867,6 +1064,8 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
   next_local_advert = next_flood_advert = 0;
   dirty_contacts_expiry = 0;
   set_radio_at = revert_radio_at = 0;
+  active_sf = 0;
+  active_cr = 0;
   _logging = false;
   region_load_active = false;
 
@@ -896,6 +1095,19 @@ MyMesh::MyMesh(mesh::MainBoard &board, mesh::Radio &radio, mesh::MillisecondCloc
   _prefs.flood_max_advert = 8;
   _prefs.interference_threshold = 0; // disabled
   _prefs.cad_enabled = 0;            // hardware CAD before TX (off by default; 'set cad on')
+  _prefs.retry_preset = RETRY_PRESET_ROOFTOP;
+  _prefs.direct_retry_attempts = DIRECT_RETRY_ROOFTOP_COUNT;
+  _prefs.direct_retry_base_ms = DIRECT_RETRY_ROOFTOP_BASE_MS;
+  _prefs.direct_retry_step_ms = DIRECT_RETRY_ROOFTOP_STEP_MS;
+  _prefs.direct_retry_snr_margin_x4 = DIRECT_RETRY_ROOFTOP_MARGIN_X4;
+  _prefs.direct_retry_cr4_snr_x4 = DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT;
+  _prefs.direct_retry_cr5_snr_x4 = DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT;
+  _prefs.direct_retry_cr7_snr_x4 = DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT;
+  _prefs.direct_retry_cr8_snr_x4 = DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT;
+  _prefs.direct_retry_enabled = 1;
+  _prefs.direct_retry_cr_enabled = 1;
+  _prefs.direct_retry_prefs_magic[0] = DIRECT_RETRY_PREFS_MAGIC_0;
+  _prefs.direct_retry_prefs_magic[1] = DIRECT_RETRY_PREFS_MAGIC_1;
 
   // bridge defaults
   _prefs.bridge_enabled = 1;    // enabled
@@ -964,6 +1176,8 @@ void MyMesh::begin(FILESYSTEM *fs) {
 #endif
 
   radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+  active_sf = _prefs.sf;
+  active_cr = _prefs.cr;
   radio_driver.setTxPower(_prefs.tx_power_dbm);
 
   radio_driver.setRxBoostedGainMode(_prefs.rx_boosted_gain);
@@ -1420,12 +1634,16 @@ void MyMesh::loop() {
   if (set_radio_at && millisHasNowPassed(set_radio_at)) { // apply pending (temporary) radio params
     set_radio_at = 0;                                     // clear timer
     radio_driver.setParams(pending_freq, pending_bw, pending_sf, pending_cr);
+    active_sf = pending_sf;
+    active_cr = pending_cr;
     MESH_DEBUG_PRINTLN("Temp radio params");
   }
 
   if (revert_radio_at && millisHasNowPassed(revert_radio_at)) { // revert radio params to orig
     revert_radio_at = 0;                                        // clear timer
     radio_driver.setParams(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    active_sf = _prefs.sf;
+    active_cr = _prefs.cr;
     MESH_DEBUG_PRINTLN("Radio params restored");
   }
 
diff --git a/examples/simple_repeater/MyMesh.h b/examples/simple_repeater/MyMesh.h
index 36c66c3f..467a4186 100644
--- a/examples/simple_repeater/MyMesh.h
+++ b/examples/simple_repeater/MyMesh.h
@@ -85,9 +85,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   uint32_t last_millis;
   uint64_t uptime_millis;
   unsigned long next_local_advert, next_flood_advert;
-  unsigned long next_battery_alert_check;
-  unsigned long last_battery_alert_sent;
-  bool battery_alert_sent;
   bool _logging;
   NodePrefs _prefs;
   ClientACL  acl;
@@ -102,15 +99,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   RegionEntry* recv_pkt_region;
   TransportKey default_scope;
   RateLimiter discover_limiter, anon_limiter;
-  struct FloodRetryBridgeState {
-    uint8_t key[MAX_HASH_SIZE];
-    uint8_t source_bucket;
-    uint8_t target_mask;
-    uint8_t heard_mask;
-    uint8_t progress_marker;
-    bool active;
-  };
-  mutable FloodRetryBridgeState flood_retry_bridge_states[MAX_FLOOD_RETRY_SLOTS];
   uint32_t pending_discover_tag;
   unsigned long pending_discover_until;
   bool region_load_active;
@@ -122,7 +110,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   unsigned long set_radio_at, revert_radio_at;
   float pending_freq;
   float pending_bw;
-  float active_bw;     // live BW, including temporary radio overrides
   uint8_t pending_sf;
   uint8_t active_sf;  // live SF, including temporary radio overrides
   uint8_t pending_cr;
@@ -137,28 +124,8 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   bool extractDirectRetryPrefix(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const;
   int8_t getDirectRetryMinSNRX4() const;
   uint8_t getDirectRetryCodingRateForSNR(int8_t snr_x4) const;
-  uint8_t getDirectRetryPreset() const;
   uint8_t getDirectRetryConfiguredMaxAttempts() const;
   uint32_t getDirectRetryAttemptStepMillis() const;
-  bool hasFloodRetryPrefixes() const;
-  bool floodRetryPrefixMatches(const mesh::Packet* packet) const;
-  bool floodRetryLastHopMatches(const mesh::Packet* packet) const;
-  bool floodRetryPrefixIgnored(const uint8_t* prefix, uint8_t prefix_len) const;
-  uint8_t floodRetryEffectivePathLength(const mesh::Packet* packet, uint8_t max_hops = 0xFF) const;
-  bool floodRetryPrefixFresh(const uint8_t* prefix, uint8_t prefix_len) const;
-  int floodRetryBucketForPrefix(const uint8_t* prefix, uint8_t prefix_len, bool require_fresh,
-                                bool include_other) const;
-  int floodRetryBucketForPathHop(const uint8_t* prefix, uint8_t prefix_len, uint8_t hop,
-                                 uint8_t progress_marker) const;
-  int floodRetrySourceBucket(const mesh::Packet* packet) const;
-  uint8_t floodRetryBridgeTargetMask(uint8_t source_bucket) const;
-  uint8_t floodRetryBridgeHeardMask(const mesh::Packet* packet, uint8_t source_bucket,
-                                    uint8_t progress_marker) const;
-  FloodRetryBridgeState* floodRetryBridgeStateFor(const mesh::Packet* packet, bool create) const;
-  void clearFloodRetryBridgeState(const mesh::Packet* packet);
-  void refreshFloodRetryHeardRecent(const mesh::Packet* packet);
-  void formatFloodRetryPath(char* dest, size_t dest_len, const mesh::Packet* packet) const;
-  bool formatFloodRetryHeard(char* dest, size_t dest_len, const mesh::Packet* packet) const;
   void putNeighbour(const mesh::Identity& id, uint32_t timestamp, float snr);
   uint8_t handleLoginReq(const mesh::Identity& sender, const uint8_t* secret, uint32_t sender_timestamp, const uint8_t* data, bool is_flood);
   uint8_t handleAnonRegionsReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data);
@@ -166,8 +133,6 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   uint8_t handleAnonClockReq(const mesh::Identity& sender, uint32_t sender_timestamp, const uint8_t* data);
   int handleRequest(ClientInfo* sender, uint32_t sender_timestamp, uint8_t* payload, size_t payload_len);
   mesh::Packet* createSelfAdvert();
-  bool sendRepeatersFloodText(const char* text);
-  void checkBatteryAlert();
 
   File openAppend(const char* fname);
   bool isLooped(const mesh::Packet* packet, const uint8_t max_counters[]);
@@ -190,18 +155,13 @@ protected:
   uint32_t getDirectRetransmitDelay(const mesh::Packet* packet) override;
   uint8_t getDefaultTxCodingRate() const override { return active_cr; }
   bool allowDirectRetry(const mesh::Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const override;
-  bool maybeShortCircuitDirect(mesh::Packet* packet) override;
   void configureDirectRetryPacket(mesh::Packet* retry, const mesh::Packet* original, uint8_t retry_attempt) override;
   uint32_t getDirectRetryEchoDelay(const mesh::Packet* packet) const override;
   uint8_t getDirectRetryMaxAttempts(const mesh::Packet* packet) const override;
   uint32_t getDirectRetryAttemptDelay(const mesh::Packet* packet, uint8_t attempt_idx) override;
   void onDirectRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) override;
-  bool allowFloodRetry(const mesh::Packet* packet) const override;
-  void onFloodRetryEvent(const char* event, const mesh::Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) override;
-  bool hasFloodRetryTargetPrefix(const mesh::Packet* packet) const override;
-  uint8_t getFloodRetryMaxPathLength(const mesh::Packet* packet) const override;
-  uint8_t getFloodRetryMaxAttempts(const mesh::Packet* packet) const override;
-  bool isFloodRetryEchoTarget(const mesh::Packet* packet, uint8_t progress_marker) const override;
+  void onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) override;
+  void onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) override;
 
   int getInterferenceThreshold() const override {
     return _prefs.interference_threshold;
@@ -233,20 +193,6 @@ protected:
   void onControlDataRecv(mesh::Packet* packet) override;
 
   void sendFloodReply(mesh::Packet* packet, unsigned long delay_millis, uint8_t path_hash_size);
-  mesh::Packet* createPacketCopy(const mesh::Packet* packet, const char* caller);
-  mesh::Packet* createAltPathCopy(const mesh::Packet* packet,
-                                  const uint8_t* primary_path, uint8_t primary_path_len,
-                                  const uint8_t* alt_path, uint8_t alt_path_len);
-  void sendFloodReplyWithAltPath(mesh::Packet* packet,
-                                 const uint8_t* direct_path, uint8_t direct_path_len,
-                                 const uint8_t* alt_path, uint8_t alt_path_len,
-                                 unsigned long delay_millis, uint8_t path_hash_size);
-  void sendDirectWithAltPath(mesh::Packet* packet,
-                             const uint8_t* path, uint8_t path_len,
-                             const uint8_t* alt_path, uint8_t alt_path_len,
-                             uint32_t delay_millis);
-  void sendFloodScopedWithSelfPath(const TransportKey& scope, mesh::Packet* pkt,
-                                   uint32_t delay_millis, uint8_t path_hash_size);
 
 public:
   MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables);
@@ -287,6 +233,9 @@ public:
   void formatStatsReply(char *reply) override;
   void formatRadioStatsReply(char *reply) override;
   void formatPacketStatsReply(char *reply) override;
+  void formatRecentRepeatersReply(char *reply, int page) override;
+  bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) override;
+  void clearRecentRepeaters() override;
   void startRegionsLoad() override;
   bool saveRegions() override;
   void onDefaultRegionChanged(const RegionEntry* r) override;
diff --git a/src/Dispatcher.cpp b/src/Dispatcher.cpp
index b870be9e..aee81a04 100644
--- a/src/Dispatcher.cpp
+++ b/src/Dispatcher.cpp
@@ -52,11 +52,15 @@ void Dispatcher::updateTxBudget() {
   }
 }
 
-void Dispatcher::restoreOutboundCodingRate() {
+void Dispatcher::restoreOutboundTxOverrides() {
   if (outbound_restore_cr != 0) {
     _radio->setCodingRate(outbound_restore_cr);
     outbound_restore_cr = 0;
   }
+  if (outbound_restore_preamble_len != 0) {
+    _radio->setPreambleLength(outbound_restore_preamble_len);
+    outbound_restore_preamble_len = 0;
+  }
 }
 
 int Dispatcher::calcRxDelay(float score, uint32_t air_time) const {
@@ -113,7 +117,7 @@ void Dispatcher::loop() {
       }
 
       _radio->onSendFinished();
-      restoreOutboundCodingRate();
+      restoreOutboundTxOverrides();
       logTx(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
       onSendComplete(outbound);
       if (outbound->isRouteFlood()) {
@@ -127,7 +131,7 @@ void Dispatcher::loop() {
       MESH_DEBUG_PRINTLN("%s Dispatcher::loop(): WARNING: outbound packed send timed out!", getLogDateTime());
 
       _radio->onSendFinished();
-      restoreOutboundCodingRate();
+      restoreOutboundTxOverrides();
       logTxFail(outbound, 2 + outbound->getPathByteLen() + outbound->payload_len);
       onSendFail(outbound);
 
@@ -342,22 +346,37 @@ void Dispatcher::checkSend() {
 
       uint32_t max_airtime = _radio->getEstAirtimeFor(len)*3/2;
       outbound_restore_cr = 0;
+      outbound_restore_preamble_len = 0;
       uint8_t default_cr = getDefaultTxCodingRate();
+      bool using_low_retry_cr = false;
       if (outbound->tx_cr >= 4 && outbound->tx_cr <= 8 && default_cr >= 4 && default_cr <= 8
           && outbound->tx_cr != default_cr) {
         if (_radio->setCodingRate(outbound->tx_cr)) {
           outbound_restore_cr = default_cr;
+          using_low_retry_cr = outbound->tx_cr == 4 || outbound->tx_cr == 5;
           max_airtime = _radio->getEstAirtimeFor(len)*3/2;
         } else {
           MESH_DEBUG_PRINTLN("%s Dispatcher::checkSend(): WARN: failed to set packet CR%d", getLogDateTime(), (uint32_t)outbound->tx_cr);
         }
+      } else if (outbound->tx_cr == 4 || outbound->tx_cr == 5) {
+        using_low_retry_cr = outbound->tx_cr == default_cr;
+      }
+      bool has_direct_path = outbound->getPathHashCount() > 0
+          || (outbound->getPayloadType() == PAYLOAD_TYPE_TRACE && outbound->payload_len > 9);
+      if (outbound->isRouteDirect() && has_direct_path
+          && using_low_retry_cr) {
+        uint16_t default_preamble_len = _radio->getDefaultPreambleLength();
+        if (default_preamble_len > 16 && _radio->setPreambleLength(16)) {
+          outbound_restore_preamble_len = default_preamble_len;
+          max_airtime = _radio->getEstAirtimeFor(len)*3/2;
+        }
       }
       outbound_start = _ms->getMillis();
       bool success = _radio->startSendRaw(raw, len);
       if (!success) {
         MESH_DEBUG_PRINTLN("%s Dispatcher::loop(): ERROR: send start failed!", getLogDateTime());
 
-        restoreOutboundCodingRate();
+        restoreOutboundTxOverrides();
         logTxFail(outbound, outbound->getRawLength());
         onSendFail(outbound);
   
diff --git a/src/Dispatcher.h b/src/Dispatcher.h
index 65e3da9e..cb86bb4b 100644
--- a/src/Dispatcher.h
+++ b/src/Dispatcher.h
@@ -51,6 +51,8 @@ public:
    * \returns true if the radio accepted the coding rate.
   */
   virtual bool setCodingRate(uint8_t cr) { return false; }
+  virtual uint16_t getDefaultPreambleLength() const { return 0; }
+  virtual bool setPreambleLength(uint16_t len) { return false; }
 
   /**
    * \returns true if the previous 'startSendRaw()' completed successfully.
@@ -124,6 +126,7 @@ typedef uint32_t  DispatcherAction;
 class Dispatcher {
   Packet* outbound;  // current outbound packet
   unsigned long outbound_expiry, outbound_start, total_air_time, rx_air_time;
+  uint16_t outbound_restore_preamble_len;
   uint8_t outbound_restore_cr;
   unsigned long next_tx_time;
   unsigned long cad_busy_start;
@@ -137,7 +140,7 @@ class Dispatcher {
   unsigned long duty_cycle_window_ms;
 
   void processRecvPacket(Packet* pkt);
-  void restoreOutboundCodingRate();
+  void restoreOutboundTxOverrides();
   void updateTxBudget();
 
 protected:
@@ -150,6 +153,7 @@ protected:
     : _radio(&radio), _ms(&ms), _mgr(&mgr)
   {
     outbound = NULL;
+    outbound_restore_preamble_len = 0;
     outbound_restore_cr = 0;
     total_air_time = rx_air_time = 0;
     next_tx_time = ms.getMillis();
@@ -210,9 +214,8 @@ public:
   bool millisHasNowPassed(unsigned long timestamp) const;
   unsigned long futureMillis(int millis_from_now) const;
 
-  bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
-
 private:
+  bool tryParsePacket(Packet* pkt, const uint8_t* raw, int len);
   void checkRecv();
   void checkSend();
 };
diff --git a/src/Mesh.cpp b/src/Mesh.cpp
index 0f05284b..b4977125 100644
--- a/src/Mesh.cpp
+++ b/src/Mesh.cpp
@@ -37,6 +37,8 @@ void Mesh::begin() {
     _direct_retries[i].retry_at = 0;
     _direct_retries[i].retry_delay = 0;
     _direct_retries[i].retry_attempts_sent = 0;
+    memset(_direct_retries[i].next_hop_hash, 0, sizeof(_direct_retries[i].next_hop_hash));
+    _direct_retries[i].next_hop_hash_len = 0;
     _direct_retries[i].priority = 0;
     _direct_retries[i].progress_marker = 0;
     _direct_retries[i].expect_path_growth = false;
@@ -78,6 +80,7 @@ void Mesh::loop() {
         : (uint32_t)(_ms->getMillis() - _direct_retries[i].retry_started_at);
       onDirectRetryEvent("failed_all_tries", _direct_retries[i].packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
       onDirectRetryEvent("failure", _direct_retries[i].packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
+      onDirectRetryFailed(_direct_retries[i].next_hop_hash, _direct_retries[i].next_hop_hash_len);
       clearDirectRetrySlot(i);
       continue;
     }
@@ -577,9 +580,6 @@ void Mesh::routeDirectRecvAcks(Packet* packet, uint32_t delay_millis) {
 }
 
 void Mesh::clearDirectRetrySlot(int idx) {
-  if (_direct_retries[idx].waiting_final_echo && _direct_retries[idx].packet != NULL) {
-    releasePacket(_direct_retries[idx].packet);
-  }
   _direct_retries[idx].packet = NULL;
   _direct_retries[idx].trigger_packet = NULL;
   _direct_retries[idx].retry_started_at = 0;
@@ -587,6 +587,8 @@ void Mesh::clearDirectRetrySlot(int idx) {
   _direct_retries[idx].retry_at = 0;
   _direct_retries[idx].retry_delay = 0;
   _direct_retries[idx].retry_attempts_sent = 0;
+  memset(_direct_retries[idx].next_hop_hash, 0, sizeof(_direct_retries[idx].next_hop_hash));
+  _direct_retries[idx].next_hop_hash_len = 0;
   _direct_retries[idx].priority = 0;
   _direct_retries[idx].progress_marker = 0;
   _direct_retries[idx].expect_path_growth = false;
@@ -627,6 +629,7 @@ bool Mesh::cancelDirectRetryOnEcho(const Packet* packet) {
     }
 
     int8_t echo_snr_x4 = packet->_snr;
+    onDirectRetrySucceeded(_direct_retries[i].next_hop_hash, _direct_retries[i].next_hop_hash_len, echo_snr_x4);
     if (_direct_retries[i].queued || _direct_retries[i].waiting_final_echo) {
       if (_direct_retries[i].packet != NULL) {
         // Success quality comes from the received downstream echo, not the original upstream RX.
@@ -689,16 +692,9 @@ void Mesh::armDirectRetryOnSendComplete(const Packet* packet) {
           max_attempts = DIRECT_RETRY_MAX_ATTEMPTS_HARD_MAX;
         }
         if (_direct_retries[i].retry_attempts_sent >= max_attempts) {
-          Packet* final_wait = obtainNewPacket();
-          if (final_wait == NULL) {
-            onDirectRetryEvent("dropped_no_packet", packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
-            onDirectRetryEvent("failure", packet, elapsed_millis, _direct_retries[i].retry_attempts_sent);
-            clearDirectRetrySlot(i);
-            continue;
-          }
-
-          *final_wait = *packet;
-          _direct_retries[i].packet = final_wait;
+          // Dispatcher releases the retry packet after this hook. Keep only retry metadata
+          // for the final echo window so pool exhaustion cannot force a premature failure.
+          _direct_retries[i].packet = NULL;
           _direct_retries[i].retry_at = futureMillis(_direct_retries[i].retry_delay);
           _direct_retries[i].waiting_final_echo = true;
           _direct_retries[i].queued = false;
@@ -941,6 +937,9 @@ void Mesh::maybeScheduleDirectRetry(const Packet* packet, uint8_t priority) {
   _direct_retries[slot_idx].retry_at = 0;
   _direct_retries[slot_idx].retry_delay = retry_delay;
   _direct_retries[slot_idx].retry_attempts_sent = 0;
+  memset(_direct_retries[slot_idx].next_hop_hash, 0, sizeof(_direct_retries[slot_idx].next_hop_hash));
+  memcpy(_direct_retries[slot_idx].next_hop_hash, next_hop_hash, next_hop_hash_len);
+  _direct_retries[slot_idx].next_hop_hash_len = next_hop_hash_len;
   _direct_retries[slot_idx].priority = priority;
   _direct_retries[slot_idx].progress_marker = progress_marker;
   _direct_retries[slot_idx].expect_path_growth = expect_path_growth;
@@ -1341,7 +1340,9 @@ Packet* Mesh::createGroupDatagram(uint8_t type, const GroupChannel& channel, con
   return packet;
 }
 
-Packet* Mesh::createAck(const uint8_t* ack, uint8_t len) {
+Packet* Mesh::createAck(const uint8_t* ack_hash, uint8_t ack_len) {
+  if (ack_len > sizeof(Packet::payload)) return NULL;
+
   Packet* packet = obtainNewPacket();
   if (packet == NULL) {
     MESH_DEBUG_PRINTLN("%s Mesh::createAck(): error, packet pool empty", getLogDateTime());
@@ -1349,13 +1350,19 @@ Packet* Mesh::createAck(const uint8_t* ack, uint8_t len) {
   }
   packet->header = (PAYLOAD_TYPE_ACK << PH_TYPE_SHIFT);  // ROUTE_TYPE_* set later
 
-  memcpy(packet->payload, ack, len);
-  packet->payload_len = len;
+  memcpy(packet->payload, ack_hash, ack_len);
+  packet->payload_len = ack_len;
 
   return packet;
 }
 
-Packet* Mesh::createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining) {
+Packet* Mesh::createAck(uint32_t ack_crc) {
+  return createAck((const uint8_t*)&ack_crc, 4);
+}
+
+Packet* Mesh::createMultiAck(const uint8_t* ack_hash, uint8_t ack_len, uint8_t remaining) {
+  if (ack_len + 1 > sizeof(Packet::payload)) return NULL;
+
   Packet* packet = obtainNewPacket();
   if (packet == NULL) {
     MESH_DEBUG_PRINTLN("%s Mesh::createMultiAck(): error, packet pool empty", getLogDateTime());
@@ -1364,12 +1371,16 @@ Packet* Mesh::createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining)
   packet->header = (PAYLOAD_TYPE_MULTIPART << PH_TYPE_SHIFT);  // ROUTE_TYPE_* set later
 
   packet->payload[0] = (remaining << 4) | PAYLOAD_TYPE_ACK;
-  memcpy(&packet->payload[1], ack, len);
-  packet->payload_len = 1 + len;
+  memcpy(&packet->payload[1], ack_hash, ack_len);
+  packet->payload_len = 1 + ack_len;
 
   return packet;
 }
 
+Packet* Mesh::createMultiAck(uint32_t ack_crc, uint8_t remaining) {
+  return createMultiAck((const uint8_t*)&ack_crc, 4, remaining);
+}
+
 Packet* Mesh::createRawData(const uint8_t* data, size_t len) {
   if (len > sizeof(Packet::payload)) return NULL;  // invalid arg
 
diff --git a/src/Mesh.h b/src/Mesh.h
index 5f2cd8ab..10beb4e6 100644
--- a/src/Mesh.h
+++ b/src/Mesh.h
@@ -46,6 +46,8 @@ class Mesh : public Dispatcher {
     uint32_t retry_delay;
     uint8_t retry_attempts_sent;
     uint8_t retry_key[MAX_HASH_SIZE];
+    uint8_t next_hop_hash[MAX_HASH_SIZE];
+    uint8_t next_hop_hash_len;
     uint8_t priority;
     uint8_t progress_marker;
     bool expect_path_growth;
@@ -132,7 +134,7 @@ protected:
 
   /**
    * \brief  Decide whether a DIRECT packet should get one delayed retry if the next hop echo is not overheard.
-   *         Sub-classes can use neighbour tables or other link-quality data to opt in selectively.
+   *         Sub-classes can use recent repeater or other link-quality data to opt in selectively.
    */
   virtual bool allowDirectRetry(const Packet* packet, const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) const;
 
@@ -201,6 +203,16 @@ protected:
    */
   virtual void onDirectRetryEvent(const char* event, const Packet* packet, uint32_t delay_millis, uint8_t retry_attempt) { }
 
+  /**
+   * \brief  Optional hook for link-quality feedback when all direct-retry attempts fail.
+   */
+  virtual void onDirectRetryFailed(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len) { }
+
+  /**
+   * \brief  Optional hook for link-quality feedback when a direct-retry echo is heard.
+   */
+  virtual void onDirectRetrySucceeded(const uint8_t* next_hop_hash, uint8_t next_hop_hash_len, int8_t snr_x4) { }
+
   /**
    * \brief  Optional hook to set local-only transmit options on a retry packet before it is queued.
    */
@@ -321,10 +333,10 @@ public:
   Packet* createDatagram(uint8_t type, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t len);
   Packet* createAnonDatagram(uint8_t type, const LocalIdentity& sender, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t data_len);
   Packet* createGroupDatagram(uint8_t type, const GroupChannel& channel, const uint8_t* data, size_t data_len);
-  Packet* createAck(const uint8_t* ack, uint8_t len);
-  Packet* createAck(uint32_t ack_crc) { return createAck((uint8_t *) &ack_crc, 4); }
-  Packet* createMultiAck(const uint8_t* ack, uint8_t len, uint8_t remaining);
-  Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining) { return createMultiAck((uint8_t *)&ack_crc, 4, remaining); }
+  Packet* createAck(const uint8_t* ack_hash, uint8_t ack_len);
+  Packet* createAck(uint32_t ack_crc);
+  Packet* createMultiAck(const uint8_t* ack_hash, uint8_t ack_len, uint8_t remaining);
+  Packet* createMultiAck(uint32_t ack_crc, uint8_t remaining);
   Packet* createPathReturn(const uint8_t* dest_hash, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
   Packet* createPathReturn(const Identity& dest, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
   Packet* createRawData(const uint8_t* data, size_t len);
diff --git a/src/helpers/CommonCLI.cpp b/src/helpers/CommonCLI.cpp
index 0adcc972..6ee5ec93 100644
--- a/src/helpers/CommonCLI.cpp
+++ b/src/helpers/CommonCLI.cpp
@@ -11,6 +11,8 @@
 #define BRIDGE_MAX_BAUD 115200
 #endif
 
+#define RECENT_REPEATER_PREFIX_MAX_BYTES  3
+
 // Believe it or not, this std C function is busted on some platforms!
 static uint32_t _atoi(const char* sp) {
   uint32_t n = 0;
@@ -29,6 +31,151 @@ static bool isValidName(const char *n) {
   return true;
 }
 
+static bool looksNumeric(const char* s) {
+  if (s == NULL) return false;
+  while (*s == ' ') s++;
+  if (*s == '-' || *s == '+') s++;
+  bool saw_digit = false;
+  bool saw_dot = false;
+  while (*s) {
+    if (*s >= '0' && *s <= '9') {
+      saw_digit = true;
+    } else if (*s == '.' && !saw_dot) {
+      saw_dot = true;
+    } else if (*s == ' ') {
+      while (*s == ' ') s++;
+      return saw_digit && *s == 0;
+    } else {
+      break;
+    }
+    s++;
+  }
+  return saw_digit && *s == 0;
+}
+
+static bool looksUnsignedInteger(const char* s) {
+  if (s == NULL) return false;
+  while (*s == ' ') s++;
+  bool saw_digit = false;
+  while (*s) {
+    if (*s >= '0' && *s <= '9') {
+      saw_digit = true;
+    } else if (*s == ' ') {
+      while (*s == ' ') s++;
+      return saw_digit && *s == 0;
+    } else {
+      return false;
+    }
+    s++;
+  }
+  return saw_digit;
+}
+
+static int16_t parseSnrDbX4(const char* s) {
+  float db = atof(s);
+  return (int16_t)(db * 4.0f + (db >= 0.0f ? 0.5f : -0.5f));
+}
+
+static void formatSnrDbX4(char* dest, size_t dest_len, int16_t snr_x4) {
+  int16_t v = snr_x4;
+  const char* sign = "";
+  if (v < 0) {
+    sign = "-";
+    v = -v;
+  }
+  snprintf(dest, dest_len, "%s%d.%02d", sign, v / 4, (v % 4) * 25);
+}
+
+static const char* retryPresetName(uint8_t preset) {
+  switch (preset) {
+    case RETRY_PRESET_INFRA: return "infra";
+    case RETRY_PRESET_ROOFTOP: return "rooftop";
+    case RETRY_PRESET_MOBILE: return "mobile";
+    default: return "custom";
+  }
+}
+
+static void markDirectRetryPrefsValid(NodePrefs* prefs) {
+  prefs->direct_retry_prefs_magic[0] = DIRECT_RETRY_PREFS_MAGIC_0;
+  prefs->direct_retry_prefs_magic[1] = DIRECT_RETRY_PREFS_MAGIC_1;
+}
+
+static void applyDirectRetryPreset(NodePrefs* prefs, uint8_t preset) {
+  prefs->retry_preset = preset;
+  if (preset == RETRY_PRESET_INFRA) {
+    prefs->direct_retry_attempts = DIRECT_RETRY_INFRA_COUNT;
+    prefs->direct_retry_base_ms = DIRECT_RETRY_INFRA_BASE_MS;
+    prefs->direct_retry_step_ms = DIRECT_RETRY_INFRA_STEP_MS;
+    prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_INFRA_MARGIN_X4;
+  } else if (preset == RETRY_PRESET_MOBILE) {
+    prefs->direct_retry_attempts = DIRECT_RETRY_MOBILE_COUNT;
+    prefs->direct_retry_base_ms = DIRECT_RETRY_MOBILE_BASE_MS;
+    prefs->direct_retry_step_ms = DIRECT_RETRY_MOBILE_STEP_MS;
+    prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_MOBILE_MARGIN_X4;
+  } else {
+    prefs->retry_preset = RETRY_PRESET_ROOFTOP;
+    prefs->direct_retry_attempts = DIRECT_RETRY_ROOFTOP_COUNT;
+    prefs->direct_retry_base_ms = DIRECT_RETRY_ROOFTOP_BASE_MS;
+    prefs->direct_retry_step_ms = DIRECT_RETRY_ROOFTOP_STEP_MS;
+    prefs->direct_retry_snr_margin_x4 = DIRECT_RETRY_ROOFTOP_MARGIN_X4;
+  }
+  markDirectRetryPrefsValid(prefs);
+}
+
+static void setDefaultDirectRetryPrefs(NodePrefs* prefs) {
+  applyDirectRetryPreset(prefs, RETRY_PRESET_ROOFTOP);
+  prefs->direct_retry_cr_enabled = 1;
+  prefs->direct_retry_cr4_snr_x4 = DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT;
+  prefs->direct_retry_cr5_snr_x4 = DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT;
+  prefs->direct_retry_cr7_snr_x4 = DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT;
+  prefs->direct_retry_cr8_snr_x4 = DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT;
+  prefs->direct_retry_enabled = 1;
+  markDirectRetryPrefsValid(prefs);
+}
+
+static bool directRetryPrefsValid(const NodePrefs* prefs) {
+  return prefs->direct_retry_prefs_magic[0] == DIRECT_RETRY_PREFS_MAGIC_0
+      && prefs->direct_retry_prefs_magic[1] == DIRECT_RETRY_PREFS_MAGIC_1;
+}
+
+static bool parseRetryPreset(const char* s, uint8_t& preset) {
+  if (strcmp(s, "infra") == 0 || strcmp(s, "0") == 0) {
+    preset = RETRY_PRESET_INFRA;
+    return true;
+  }
+  if (strcmp(s, "rooftop") == 0 || strcmp(s, "1") == 0) {
+    preset = RETRY_PRESET_ROOFTOP;
+    return true;
+  }
+  if (strcmp(s, "mobile") == 0 || strcmp(s, "2") == 0) {
+    preset = RETRY_PRESET_MOBILE;
+    return true;
+  }
+  return false;
+}
+
+static bool parseHashPrefix(const char* text, uint8_t* prefix, uint8_t& prefix_len) {
+  size_t hex_len = strlen(text);
+  if (hex_len == 0 || (hex_len & 1) || hex_len > RECENT_REPEATER_PREFIX_MAX_BYTES * 2) {
+    return false;
+  }
+  for (size_t i = 0; i < hex_len; i++) {
+    if (!mesh::Utils::isHexChar(text[i])) {
+      return false;
+    }
+  }
+  prefix_len = hex_len / 2;
+  return mesh::Utils::fromHex(prefix, prefix_len, text);
+}
+
+static void formatSnrDbX4Short(char* dest, size_t dest_len, int16_t snr_x4) {
+  formatSnrDbX4(dest, dest_len, snr_x4);
+  size_t len = strlen(dest);
+  if (len > 3 && dest[len - 1] == '0') {
+    dest[len - 1] = 0;
+  }
+}
+
 void CommonCLI::loadPrefs(FILESYSTEM* fs) {
   if (fs->exists("/com_prefs")) {
     loadPrefsInt(fs, "/com_prefs");   // new filename
@@ -97,6 +244,19 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
     file.read((uint8_t *)&_prefs->radio_fem_rxgain, sizeof(_prefs->radio_fem_rxgain));             // 293
     file.read((uint8_t *)&_prefs->cad_enabled, sizeof(_prefs->cad_enabled));                       // 294
     // next: 295
+    file.read((uint8_t *)&_prefs->retry_preset, sizeof(_prefs->retry_preset));                     // 295
+    file.read((uint8_t *)&_prefs->direct_retry_attempts, sizeof(_prefs->direct_retry_attempts));   // 296
+    file.read((uint8_t *)&_prefs->direct_retry_base_ms, sizeof(_prefs->direct_retry_base_ms));     // 297
+    file.read((uint8_t *)&_prefs->direct_retry_step_ms, sizeof(_prefs->direct_retry_step_ms));     // 299
+    file.read((uint8_t *)&_prefs->direct_retry_snr_margin_x4, sizeof(_prefs->direct_retry_snr_margin_x4)); // 301
+    file.read((uint8_t *)&_prefs->direct_retry_cr4_snr_x4, sizeof(_prefs->direct_retry_cr4_snr_x4)); // 303
+    file.read((uint8_t *)&_prefs->direct_retry_cr5_snr_x4, sizeof(_prefs->direct_retry_cr5_snr_x4)); // 304
+    file.read((uint8_t *)&_prefs->direct_retry_cr7_snr_x4, sizeof(_prefs->direct_retry_cr7_snr_x4)); // 305
+    file.read((uint8_t *)&_prefs->direct_retry_cr8_snr_x4, sizeof(_prefs->direct_retry_cr8_snr_x4)); // 306
+    file.read((uint8_t *)&_prefs->direct_retry_enabled, sizeof(_prefs->direct_retry_enabled));       // 307
+    file.read((uint8_t *)&_prefs->direct_retry_cr_enabled, sizeof(_prefs->direct_retry_cr_enabled)); // 308
+    file.read((uint8_t *)&_prefs->direct_retry_prefs_magic, sizeof(_prefs->direct_retry_prefs_magic)); // 309
+    // next: 311
 
     // sanitise bad pref values
     _prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
@@ -129,6 +289,18 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
     _prefs->rx_boosted_gain = constrain(_prefs->rx_boosted_gain, 0, 1); // boolean
     _prefs->radio_fem_rxgain = constrain(_prefs->radio_fem_rxgain, 0, 1); // boolean
     _prefs->cad_enabled = constrain(_prefs->cad_enabled, 0, 1); // boolean
+    if (!directRetryPrefsValid(_prefs)) {
+      setDefaultDirectRetryPrefs(_prefs);
+    }
+    if (_prefs->retry_preset > RETRY_PRESET_MOBILE && _prefs->retry_preset != RETRY_PRESET_CUSTOM) {
+      _prefs->retry_preset = RETRY_PRESET_CUSTOM;
+    }
+    _prefs->direct_retry_attempts = constrain(_prefs->direct_retry_attempts, 1, 15);
+    _prefs->direct_retry_base_ms = constrain(_prefs->direct_retry_base_ms, 10, 5000);
+    _prefs->direct_retry_step_ms = constrain(_prefs->direct_retry_step_ms, 0, 5000);
+    _prefs->direct_retry_snr_margin_x4 = constrain(_prefs->direct_retry_snr_margin_x4, 0, 160);
+    _prefs->direct_retry_enabled = constrain(_prefs->direct_retry_enabled, 0, 1);
+    _prefs->direct_retry_cr_enabled = constrain(_prefs->direct_retry_cr_enabled, 0, 1);
 
     file.close();
   }
@@ -196,6 +368,20 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
     file.write((uint8_t *)&_prefs->radio_fem_rxgain, sizeof(_prefs->radio_fem_rxgain));             // 293
     file.write((uint8_t *)&_prefs->cad_enabled, sizeof(_prefs->cad_enabled));                       // 294
     // next: 295
+    markDirectRetryPrefsValid(_prefs);
+    file.write((uint8_t *)&_prefs->retry_preset, sizeof(_prefs->retry_preset));                     // 295
+    file.write((uint8_t *)&_prefs->direct_retry_attempts, sizeof(_prefs->direct_retry_attempts));   // 296
+    file.write((uint8_t *)&_prefs->direct_retry_base_ms, sizeof(_prefs->direct_retry_base_ms));     // 297
+    file.write((uint8_t *)&_prefs->direct_retry_step_ms, sizeof(_prefs->direct_retry_step_ms));     // 299
+    file.write((uint8_t *)&_prefs->direct_retry_snr_margin_x4, sizeof(_prefs->direct_retry_snr_margin_x4)); // 301
+    file.write((uint8_t *)&_prefs->direct_retry_cr4_snr_x4, sizeof(_prefs->direct_retry_cr4_snr_x4)); // 303
+    file.write((uint8_t *)&_prefs->direct_retry_cr5_snr_x4, sizeof(_prefs->direct_retry_cr5_snr_x4)); // 304
+    file.write((uint8_t *)&_prefs->direct_retry_cr7_snr_x4, sizeof(_prefs->direct_retry_cr7_snr_x4)); // 305
+    file.write((uint8_t *)&_prefs->direct_retry_cr8_snr_x4, sizeof(_prefs->direct_retry_cr8_snr_x4)); // 306
+    file.write((uint8_t *)&_prefs->direct_retry_enabled, sizeof(_prefs->direct_retry_enabled));       // 307
+    file.write((uint8_t *)&_prefs->direct_retry_cr_enabled, sizeof(_prefs->direct_retry_cr_enabled)); // 308
+    file.write((uint8_t *)&_prefs->direct_retry_prefs_magic, sizeof(_prefs->direct_retry_prefs_magic)); // 309
+    // next: 311
 
     file.close();
   }
@@ -306,6 +492,9 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
     } else if (memcmp(command, "clear stats", 11) == 0) {
       _callbacks->clearStats();
       strcpy(reply, "(OK - stats reset)");
+    } else if (memcmp(command, "clear recent.repeater", 21) == 0 && (command[21] == 0 || command[21] == ' ')) {
+      _callbacks->clearRecentRepeaters();
+      strcpy(reply, "OK");
     } else if (memcmp(command, "get ", 4) == 0) {
       handleGetCmd(sender_timestamp, command, reply);
     } else if (memcmp(command, "set ", 4) == 0) {
@@ -481,7 +670,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, char* command, char* re
       // GPS
 #if defined(PIN_GPS_RX) && defined(PIN_GPS_TX)
       sprintf(reply + strlen(reply), "GPS Serial: RX=%s, TX=%s", STR(PIN_GPS_RX), STR(PIN_GPS_TX));
-#ifdef ENV_INCLUDE_GPS> 0
+#if defined(ENV_INCLUDE_GPS) && ENV_INCLUDE_GPS > 0
       sprintf(reply + strlen(reply), ". Configured");
 #else
       sprintf(reply + strlen(reply), ". Not configured");
@@ -715,6 +904,128 @@ void CommonCLI::handleSetCmd(uint32_t sender_timestamp, char* command, char* rep
     } else {
       strcpy(reply, "Error, must be 0-2");
     }
+  } else if (memcmp(config, "retry.preset ", 13) == 0) {
+    uint8_t preset;
+    if (parseRetryPreset(&config[13], preset)) {
+      applyDirectRetryPreset(_prefs, preset);
+      savePrefs();
+      sprintf(reply, "OK - %s", retryPresetName(_prefs->retry_preset));
+    } else {
+      strcpy(reply, "Error, must be infra, rooftop, or mobile");
+    }
+  } else if (memcmp(config, "direct.retry ", 13) == 0) {
+    if (strcmp(&config[13], "on") == 0) {
+      _prefs->direct_retry_enabled = 1;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else if (strcmp(&config[13], "off") == 0) {
+      _prefs->direct_retry_enabled = 0;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be on or off");
+    }
+  } else if (memcmp(config, "direct.retry.margin ", 20) == 0) {
+    if (!looksNumeric(&config[20])) {
+      strcpy(reply, "Error, must be 0-40 dB");
+    } else {
+      int16_t margin_x4 = parseSnrDbX4(&config[20]);
+      if (margin_x4 >= 0 && margin_x4 <= 160) {
+        _prefs->direct_retry_snr_margin_x4 = (uint16_t)margin_x4;
+        _prefs->retry_preset = RETRY_PRESET_CUSTOM;
+        savePrefs();
+        strcpy(reply, "OK");
+      } else {
+        strcpy(reply, "Error, must be 0-40 dB");
+      }
+    }
+  } else if (memcmp(config, "direct.retry.count ", 19) == 0) {
+    int attempts = looksUnsignedInteger(&config[19]) ? _atoi(&config[19]) : -1;
+    if (attempts >= 1 && attempts <= 15) {
+      _prefs->direct_retry_attempts = (uint8_t)attempts;
+      _prefs->retry_preset = RETRY_PRESET_CUSTOM;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 1-15");
+    }
+  } else if (memcmp(config, "direct.retry.base ", 18) == 0) {
+    int base_ms = looksUnsignedInteger(&config[18]) ? _atoi(&config[18]) : -1;
+    if (base_ms >= 10 && base_ms <= 5000) {
+      _prefs->direct_retry_base_ms = (uint16_t)base_ms;
+      _prefs->retry_preset = RETRY_PRESET_CUSTOM;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 10-5000 ms");
+    }
+  } else if (memcmp(config, "direct.retry.step ", 18) == 0) {
+    int step_ms = looksUnsignedInteger(&config[18]) ? _atoi(&config[18]) : -1;
+    if (step_ms >= 0 && step_ms <= 5000) {
+      _prefs->direct_retry_step_ms = (uint16_t)step_ms;
+      _prefs->retry_preset = RETRY_PRESET_CUSTOM;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else {
+      strcpy(reply, "Error, must be 0-5000 ms");
+    }
+  } else if (memcmp(config, "direct.retry.cr ", 16) == 0) {
+    if (strcmp(&config[16], "off") == 0) {
+      _prefs->direct_retry_cr_enabled = 0;
+      savePrefs();
+      strcpy(reply, "OK");
+    } else {
+      strcpy(tmp, &config[16]);
+      const char *parts[4];
+      int num = mesh::Utils::parseTextParts(tmp, parts, 4, ',');
+      if (num == 4 && looksNumeric(parts[0]) && looksNumeric(parts[1]) && looksNumeric(parts[2]) && looksNumeric(parts[3])) {
+        int16_t cr4 = parseSnrDbX4(parts[0]);
+        int16_t cr5 = parseSnrDbX4(parts[1]);
+        int16_t cr7 = parseSnrDbX4(parts[2]);
+        int16_t cr8 = parseSnrDbX4(parts[3]);
+        if (cr4 >= -128 && cr4 <= 127 && cr5 >= -128 && cr5 <= 127 && cr7 >= -128 && cr7 <= 127 && cr8 >= -128 && cr8 <= 127) {
+          _prefs->direct_retry_cr4_snr_x4 = (int8_t)cr4;
+          _prefs->direct_retry_cr5_snr_x4 = (int8_t)cr5;
+          _prefs->direct_retry_cr7_snr_x4 = (int8_t)cr7;
+          _prefs->direct_retry_cr8_snr_x4 = (int8_t)cr8;
+          _prefs->direct_retry_cr_enabled = 1;
+          savePrefs();
+          strcpy(reply, "OK");
+        } else {
+          strcpy(reply, "Error, SNR must fit -32.00..31.75 dB");
+        }
+      } else {
+        strcpy(reply, "Error, use CR4,CR5,CR7,CR8 SNRs or off");
+      }
+    }
+  } else if (memcmp(config, "recent.repeater ", 16) == 0) {
+    strcpy(tmp, &config[16]);
+    const char *parts[2];
+    int num = mesh::Utils::parseTextParts(tmp, parts, 2, ' ');
+    uint8_t prefix[MAX_HASH_SIZE];
+    uint8_t prefix_len = 0;
+    int16_t snr_x4 = 12;  // default to +3.0 dB when omitted or invalid
+    if (num < 1 || !parseHashPrefix(parts[0], prefix, prefix_len)) {
+      strcpy(reply, "Error, use: set recent.repeater <hex> [snr_db]");
+    } else if (num > 1 && !looksNumeric(parts[1])) {
+      strcpy(reply, "Error, SNR must be numeric");
+    } else {
+      if (num > 1) {
+        snr_x4 = parseSnrDbX4(parts[1]);
+      }
+      if (snr_x4 < -128 || snr_x4 > 127) {
+        strcpy(reply, "Error, SNR must fit -32.00..31.75 dB");
+      } else if (_callbacks->setRecentRepeater(prefix, prefix_len, (int8_t)snr_x4)) {
+        char prefix_hex[RECENT_REPEATER_PREFIX_MAX_BYTES * 2 + 1];
+        char snr[12];
+        mesh::Utils::toHex(prefix_hex, prefix, prefix_len);
+        prefix_hex[prefix_len * 2] = 0;
+        formatSnrDbX4Short(snr, sizeof(snr), snr_x4);
+        sprintf(reply, "OK - set %s at %s SNR", prefix_hex, snr);
+      } else {
+        strcpy(reply, "Error, table rejected prefix");
+      }
+    }
   } else if (memcmp(config, "owner.info ", 11) == 0) {
     config += 11;
     char *dp = _prefs->owner_info;
@@ -910,6 +1221,38 @@ void CommonCLI::handleGetCmd(uint32_t sender_timestamp, char* command, char* rep
     sprintf(reply, "> %d", (uint32_t)_prefs->flood_max);
   } else if (memcmp(config, "direct.txdelay", 14) == 0) {
     sprintf(reply, "> %s", StrHelper::ftoa(_prefs->direct_tx_delay_factor));
+  } else if (memcmp(config, "retry.preset", 12) == 0) {
+    sprintf(reply, "> %s", retryPresetName(_prefs->retry_preset));
+  } else if (memcmp(config, "direct.retry", 12) == 0 && (config[12] == 0 || config[12] == ' ')) {
+    sprintf(reply, "> %s", _prefs->direct_retry_enabled ? "on" : "off");
+  } else if (memcmp(config, "direct.retry.margin", 19) == 0) {
+    char margin[12];
+    formatSnrDbX4(margin, sizeof(margin), _prefs->direct_retry_snr_margin_x4);
+    sprintf(reply, "> %s", margin);
+  } else if (memcmp(config, "direct.retry.count", 18) == 0) {
+    sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_attempts);
+  } else if (memcmp(config, "direct.retry.base", 17) == 0) {
+    sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_base_ms);
+  } else if (memcmp(config, "direct.retry.step", 17) == 0) {
+    sprintf(reply, "> %d", (uint32_t)_prefs->direct_retry_step_ms);
+  } else if (memcmp(config, "direct.retry.cr", 15) == 0) {
+    if (!_prefs->direct_retry_cr_enabled) {
+      strcpy(reply, "> off");
+    } else {
+      char cr4[12], cr5[12], cr7[12], cr8[12];
+      formatSnrDbX4(cr4, sizeof(cr4), _prefs->direct_retry_cr4_snr_x4);
+      formatSnrDbX4(cr5, sizeof(cr5), _prefs->direct_retry_cr5_snr_x4);
+      formatSnrDbX4(cr7, sizeof(cr7), _prefs->direct_retry_cr7_snr_x4);
+      formatSnrDbX4(cr8, sizeof(cr8), _prefs->direct_retry_cr8_snr_x4);
+      sprintf(reply, "> %s,%s,%s,%s", cr4, cr5, cr7, cr8);
+    }
+  } else if (memcmp(config, "recent.repeater", 15) == 0) {
+    int page = 1;
+    const char* cursor = &config[15];
+    while (*cursor == ' ') cursor++;
+    if (*cursor) page = _atoi(cursor);
+    if (page < 1) page = 1;
+    _callbacks->formatRecentRepeatersReply(reply, page);
   } else if (memcmp(config, "owner.info", 10) == 0) {
     auto start = reply;
     *reply++ = '>';
diff --git a/src/helpers/CommonCLI.h b/src/helpers/CommonCLI.h
index 695d2053..5a518ea9 100644
--- a/src/helpers/CommonCLI.h
+++ b/src/helpers/CommonCLI.h
@@ -19,6 +19,34 @@
 #define LOOP_DETECT_MODERATE  2
 #define LOOP_DETECT_STRICT    3
 
+#define RETRY_PRESET_INFRA    0
+#define RETRY_PRESET_ROOFTOP  1
+#define RETRY_PRESET_MOBILE   2
+#define RETRY_PRESET_CUSTOM   0xFF
+
+#define DIRECT_RETRY_INFRA_BASE_MS      275
+#define DIRECT_RETRY_INFRA_COUNT          4
+#define DIRECT_RETRY_INFRA_STEP_MS      150
+#define DIRECT_RETRY_INFRA_MARGIN_X4     60
+
+#define DIRECT_RETRY_ROOFTOP_BASE_MS    175
+#define DIRECT_RETRY_ROOFTOP_COUNT       15
+#define DIRECT_RETRY_ROOFTOP_STEP_MS    100
+#define DIRECT_RETRY_ROOFTOP_MARGIN_X4   20
+
+#define DIRECT_RETRY_MOBILE_BASE_MS     175
+#define DIRECT_RETRY_MOBILE_COUNT        15
+#define DIRECT_RETRY_MOBILE_STEP_MS      50
+#define DIRECT_RETRY_MOBILE_MARGIN_X4     0
+
+#define DIRECT_RETRY_CR4_MIN_SNR_X4_DEFAULT  40
+#define DIRECT_RETRY_CR5_MIN_SNR_X4_DEFAULT  30
+#define DIRECT_RETRY_CR7_MIN_SNR_X4_DEFAULT  10
+#define DIRECT_RETRY_CR8_MAX_SNR_X4_DEFAULT  10
+
+#define DIRECT_RETRY_PREFS_MAGIC_0  0xD1
+#define DIRECT_RETRY_PREFS_MAGIC_1  0x52
+
 struct NodePrefs { // persisted to file
   float airtime_factor;
   char node_name[32];
@@ -66,6 +94,18 @@ struct NodePrefs { // persisted to file
   uint8_t path_hash_mode;   // which path mode to use when sending
   uint8_t loop_detect;
   uint8_t cad_enabled;      // hardware Channel Activity Detection before TX (boolean)
+  uint8_t retry_preset;
+  uint8_t direct_retry_attempts;
+  uint16_t direct_retry_base_ms;
+  uint16_t direct_retry_step_ms;
+  uint16_t direct_retry_snr_margin_x4;
+  int8_t direct_retry_cr4_snr_x4;
+  int8_t direct_retry_cr5_snr_x4;
+  int8_t direct_retry_cr7_snr_x4;
+  int8_t direct_retry_cr8_snr_x4;
+  uint8_t direct_retry_enabled;
+  uint8_t direct_retry_cr_enabled;
+  uint8_t direct_retry_prefs_magic[2];
 };
 
 class CommonCLICallbacks {
@@ -89,6 +129,18 @@ public:
   virtual void formatStatsReply(char *reply) = 0;
   virtual void formatRadioStatsReply(char *reply) = 0;
   virtual void formatPacketStatsReply(char *reply) = 0;
+  virtual void formatRecentRepeatersReply(char *reply, int page) {
+    (void)page;
+    if (reply != NULL) reply[0] = 0;
+  }
+  virtual bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
+    (void)prefix;
+    (void)prefix_len;
+    (void)snr_x4;
+    return false;
+  }
+  virtual void clearRecentRepeaters() {
+  }
   virtual mesh::LocalIdentity& getSelfId() = 0;
   virtual void saveIdentity(const mesh::LocalIdentity& new_id) = 0;
   virtual void clearStats() = 0;
diff --git a/src/helpers/SimpleMeshTables.h b/src/helpers/SimpleMeshTables.h
index 0b79cfb4..fb717bfc 100644
--- a/src/helpers/SimpleMeshTables.h
+++ b/src/helpers/SimpleMeshTables.h
@@ -7,23 +7,143 @@
 #endif
 
 #define MAX_PACKET_HASHES  (128+32)
+#ifndef MAX_RECENT_REPEATERS
+  // Platform defaults. Can be overridden with -D MAX_RECENT_REPEATERS=<n>.
+  #if defined(ESP32) || defined(ESP32_PLATFORM)
+    #define MAX_RECENT_REPEATERS  2048
+  #elif defined(NRF52_PLATFORM)
+    #define MAX_RECENT_REPEATERS  512
+  #else
+    #define MAX_RECENT_REPEATERS  64
+  #endif
+#endif
+#define MAX_ROUTE_HASH_BYTES   3
 
 class SimpleMeshTables : public mesh::MeshTables {
+public:
+  struct RecentRepeaterInfo {
+    // Identity and link quality for a next-hop path prefix.
+    uint8_t prefix[MAX_ROUTE_HASH_BYTES];
+    uint8_t prefix_len;
+    int8_t snr_x4;
+  };
+
+private:
   uint8_t _hashes[MAX_PACKET_HASHES*MAX_HASH_SIZE];
   int _next_idx;
   uint32_t _direct_dups, _flood_dups;
+  RecentRepeaterInfo _recent_repeaters[MAX_RECENT_REPEATERS];
+
+  bool hasSeenHash(const uint8_t* hash) const {
+    const uint8_t* sp = _hashes;
+    for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
+      if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void storeHash(const uint8_t* hash) {
+    memcpy(&_hashes[_next_idx*MAX_HASH_SIZE], hash, MAX_HASH_SIZE);
+    _next_idx = (_next_idx + 1) % MAX_PACKET_HASHES;
+  }
+
+  bool prefixesOverlap(const uint8_t* a, uint8_t a_len, const uint8_t* b, uint8_t b_len) const {
+    uint8_t n = a_len < b_len ? a_len : b_len;
+    return n > 0 && memcmp(a, b, n) == 0;
+  }
+
+  int8_t weightedSnrX4RoundUp(int8_t curr_snr_x4, int8_t new_snr_x4) const {
+    // Keep existing SNR heavier than a single new sample: 75% existing + 25% new.
+    int32_t weighted_sum = ((int32_t)curr_snr_x4 * 3) + (int32_t)new_snr_x4;
+    int32_t blended = weighted_sum / 4;  // truncates toward zero
+    // "Round up" means ceil(), which only differs from truncation for positive remainders.
+    if (weighted_sum > 0 && (weighted_sum % 4) != 0) {
+      blended++;
+    }
+    if (blended > 127) {
+      blended = 127;
+    } else if (blended < -128) {
+      blended = -128;
+    }
+    return (int8_t)blended;
+  }
+
+  bool extractRecentRepeater(const mesh::Packet* packet, uint8_t* prefix, uint8_t& prefix_len) const {
+    // Learn repeater prefixes only from packet shapes that expose a trustworthy repeater ID.
+    // For flood traffic, the last path entry is the repeater we directly heard.
+    if (packet->isRouteFlood() && packet->getPathHashCount() > 0) {
+      prefix_len = packet->getPathHashSize();
+      if (prefix_len > MAX_ROUTE_HASH_BYTES) {
+        prefix_len = MAX_ROUTE_HASH_BYTES;
+      }
+
+      const uint8_t* last_hop = &packet->path[(packet->getPathHashCount() - 1) * packet->getPathHashSize()];
+      memcpy(prefix, last_hop, prefix_len);
+      return true;
+    }
+
+    // If there is no flood path to inspect, fall back to payload-derived identities.
+    if (packet->getPayloadType() == PAYLOAD_TYPE_ADVERT && packet->payload_len >= PUB_KEY_SIZE) {
+      memcpy(prefix, packet->payload, MAX_ROUTE_HASH_BYTES);
+      prefix_len = MAX_ROUTE_HASH_BYTES;
+      return true;
+    }
+
+    if (packet->getPayloadType() == PAYLOAD_TYPE_CONTROL
+        && packet->isRouteDirect()
+        && packet->getPathHashCount() == 0
+        && packet->payload_len >= 6 + MAX_ROUTE_HASH_BYTES
+        && (packet->payload[0] & 0xF0) == 0x90) {
+      memcpy(prefix, &packet->payload[6], MAX_ROUTE_HASH_BYTES);
+      prefix_len = MAX_ROUTE_HASH_BYTES;
+      return true;
+    }
+
+    return false;
+  }
+
+  bool recentRepeaterComesBefore(const RecentRepeaterInfo& a, int a_idx,
+                                 const RecentRepeaterInfo& b, int b_idx) const {
+    if (a.prefix_len != b.prefix_len) {
+      return a.prefix_len > b.prefix_len;  // 3-byte prefixes, then 2-byte, then 1-byte.
+    }
+    if (a.snr_x4 != b.snr_x4) {
+      return a.snr_x4 > b.snr_x4;  // Highest SNR first within each prefix length.
+    }
+    int cmp = memcmp(a.prefix, b.prefix, a.prefix_len);
+    if (cmp != 0) {
+      return cmp < 0;
+    }
+    return a_idx < b_idx;
+  }
+
+  void recordRecentRepeater(const mesh::Packet* packet) {
+    uint8_t prefix[MAX_ROUTE_HASH_BYTES] = {0};
+    uint8_t prefix_len = 0;
+    if (!extractRecentRepeater(packet, prefix, prefix_len) || prefix_len == 0) {
+      return;
+    }
+    setRecentRepeater(prefix, prefix_len, packet->_snr);
+  }
 
 public:
   SimpleMeshTables() { 
     memset(_hashes, 0, sizeof(_hashes));
     _next_idx = 0;
     _direct_dups = _flood_dups = 0;
+    memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
   }
 
 #ifdef ESP32
   void restoreFrom(File f) {
     f.read(_hashes, sizeof(_hashes));
     f.read((uint8_t *) &_next_idx, sizeof(_next_idx));
+    // Recent repeater entries are intentionally not restored across boots.
+    // This avoids struct-layout migration issues and keeps stale path quality
+    // stats from persisting indefinitely.
+    memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
   }
   void saveTo(File f) {
     f.write(_hashes, sizeof(_hashes));
@@ -35,23 +155,29 @@ public:
     uint8_t hash[MAX_HASH_SIZE];
     packet->calculatePacketHash(hash);
 
-    const uint8_t* sp = _hashes;
-    for (int i = 0; i < MAX_PACKET_HASHES; i++, sp += MAX_HASH_SIZE) {
-      if (memcmp(hash, sp, MAX_HASH_SIZE) == 0) { 
-        if (packet->isRouteDirect()) {
-          _direct_dups++;   // keep some stats
-        } else {
-          _flood_dups++;
-        }
-        return true;
+    if (hasSeenHash(hash)) {
+      if (packet->isRouteDirect()) {
+        _direct_dups++;   // keep some stats
+      } else {
+        _flood_dups++;
       }
+      return true;
     }
 
-    memcpy(&_hashes[_next_idx*MAX_HASH_SIZE], hash, MAX_HASH_SIZE);
-    _next_idx = (_next_idx + 1) % MAX_PACKET_HASHES;  // cyclic table
+    storeHash(hash);
+    recordRecentRepeater(packet);
     return false;
   }
 
+  void markSent(const mesh::Packet* packet) override {
+    // Outbound packets must be marked as already-sent without teaching the recent-heard cache about ourselves.
+    uint8_t hash[MAX_HASH_SIZE];
+    packet->calculatePacketHash(hash);
+    if (!hasSeenHash(hash)) {
+      storeHash(hash);
+    }
+  }
+
   void clear(const mesh::Packet* packet) override {
     uint8_t hash[MAX_HASH_SIZE];
     packet->calculatePacketHash(hash);
@@ -68,5 +194,143 @@ public:
   uint32_t getNumDirectDups() const { return _direct_dups; }
   uint32_t getNumFloodDups() const { return _flood_dups; }
 
+  bool setRecentRepeater(const uint8_t* prefix, uint8_t prefix_len, int8_t snr_x4) {
+    if (prefix == NULL || prefix_len == 0) {
+      return false;
+    }
+
+    if (prefix_len > MAX_ROUTE_HASH_BYTES) {
+      prefix_len = MAX_ROUTE_HASH_BYTES;
+    }
+
+    // Keep exact prefixes distinct so a 1-byte path prefix does not collapse
+    // independent 2/3-byte repeaters that share the same first byte.
+    for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+      RecentRepeaterInfo& existing = _recent_repeaters[i];
+      if (existing.prefix_len != prefix_len || memcmp(existing.prefix, prefix, prefix_len) != 0) {
+        continue;
+      }
+      existing.snr_x4 = weightedSnrX4RoundUp(existing.snr_x4, snr_x4);
+      return true;
+    }
+
+    int slot_idx = -1;
+    for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+      if (_recent_repeaters[i].prefix_len == 0) {
+        slot_idx = i;
+        break;
+      }
+    }
+    if (slot_idx < 0) {
+      // Table is full: evict the weakest observed SNR entry.
+      slot_idx = 0;
+      int8_t min_snr_x4 = _recent_repeaters[0].snr_x4;
+      for (int i = 1; i < MAX_RECENT_REPEATERS; i++) {
+        if (_recent_repeaters[i].snr_x4 < min_snr_x4) {
+          min_snr_x4 = _recent_repeaters[i].snr_x4;
+          slot_idx = i;
+        }
+      }
+    }
+
+    RecentRepeaterInfo& slot = _recent_repeaters[slot_idx];
+    memset(slot.prefix, 0, sizeof(slot.prefix));
+    memcpy(slot.prefix, prefix, prefix_len);
+    slot.prefix_len = prefix_len;
+    slot.snr_x4 = snr_x4;
+    return true;
+  }
+  bool decrementRecentRepeaterSnrX4(const uint8_t* prefix, uint8_t prefix_len, uint8_t amount_x4 = 1) {
+    if (prefix == NULL || prefix_len == 0 || amount_x4 == 0) {
+      return false;
+    }
+    if (prefix_len > MAX_ROUTE_HASH_BYTES) {
+      prefix_len = MAX_ROUTE_HASH_BYTES;
+    }
+
+    for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+      RecentRepeaterInfo& existing = _recent_repeaters[i];
+      if (existing.prefix_len != prefix_len || memcmp(existing.prefix, prefix, prefix_len) != 0) {
+        continue;
+      }
+      int16_t lowered = (int16_t)existing.snr_x4 - (int16_t)amount_x4;
+      if (lowered < -128) {
+        lowered = -128;
+      }
+      existing.snr_x4 = (int8_t)lowered;
+      return true;
+    }
+    return false;
+  }
+  int getRecentRepeaterCount() const {
+    int count = 0;
+    for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+      if (_recent_repeaters[i].prefix_len > 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+  const RecentRepeaterInfo* getRecentRepeaterBySortedIdx(int idx_wanted) const {
+    if (idx_wanted < 0) {
+      return NULL;
+    }
+
+    const RecentRepeaterInfo* last = NULL;
+    int last_idx = -1;
+    for (int rank = 0; rank <= idx_wanted; rank++) {
+      const RecentRepeaterInfo* best = NULL;
+      int best_idx = -1;
+      for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+        const RecentRepeaterInfo* info = &_recent_repeaters[i];
+        if (info->prefix_len == 0) {
+          continue;
+        }
+        if (last != NULL && !recentRepeaterComesBefore(*last, last_idx, *info, i)) {
+          continue;
+        }
+        if (best == NULL || recentRepeaterComesBefore(*info, i, *best, best_idx)) {
+          best = info;
+          best_idx = i;
+        }
+      }
+      if (best == NULL) {
+        return NULL;
+      }
+      last = best;
+      last_idx = best_idx;
+    }
+    return last;
+  }
+
+  const RecentRepeaterInfo* findRecentRepeaterByHash(const uint8_t* hash, uint8_t hash_len) const {
+    if (hash == NULL || hash_len == 0) {
+      return NULL;
+    }
+
+    // Prefer exact matches. If none exists, fall back to the longest overlapping
+    // prefix, using highest SNR to break ties.
+    const RecentRepeaterInfo* best = NULL;
+    for (int i = 0; i < MAX_RECENT_REPEATERS; i++) {
+      const RecentRepeaterInfo* info = &_recent_repeaters[i];
+      if (info->prefix_len == 0) {
+        continue;
+      }
+      if (info->prefix_len == hash_len && memcmp(info->prefix, hash, hash_len) == 0) {
+        return info;
+      }
+      if (prefixesOverlap(info->prefix, info->prefix_len, hash, hash_len)) {
+        if (best == NULL || info->prefix_len > best->prefix_len
+            || (info->prefix_len == best->prefix_len && info->snr_x4 > best->snr_x4)) {
+          best = info;
+        }
+      }
+    }
+    return best;
+  }
+  void clearRecentRepeaters() {
+    memset(_recent_repeaters, 0, sizeof(_recent_repeaters));
+  }
+
   void resetStats() { _direct_dups = _flood_dups = 0; }
 };
diff --git a/src/helpers/radiolib/CustomLLCC68Wrapper.h b/src/helpers/radiolib/CustomLLCC68Wrapper.h
index 8861f76d..620ef864 100644
--- a/src/helpers/radiolib/CustomLLCC68Wrapper.h
+++ b/src/helpers/radiolib/CustomLLCC68Wrapper.h
@@ -16,6 +16,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomLLCC68 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   bool isReceivingPacket() override { 
     return ((CustomLLCC68 *)_radio)->isReceiving();
   }
diff --git a/src/helpers/radiolib/CustomLR1110Wrapper.h b/src/helpers/radiolib/CustomLR1110Wrapper.h
index 13efd25b..4d30f515 100644
--- a/src/helpers/radiolib/CustomLR1110Wrapper.h
+++ b/src/helpers/radiolib/CustomLR1110Wrapper.h
@@ -16,6 +16,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomLR1110 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   void doResetAGC() override { lr11x0ResetAGC((LR11x0 *)_radio, ((CustomLR1110 *)_radio)->getFreqMHz()); }
   bool isReceivingPacket() override {
     return ((CustomLR1110 *)_radio)->isReceiving();
diff --git a/src/helpers/radiolib/CustomSTM32WLxWrapper.h b/src/helpers/radiolib/CustomSTM32WLxWrapper.h
index 97bf6820..45e275a3 100644
--- a/src/helpers/radiolib/CustomSTM32WLxWrapper.h
+++ b/src/helpers/radiolib/CustomSTM32WLxWrapper.h
@@ -17,6 +17,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomSTM32WLx *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   bool isReceivingPacket() override { 
     return ((CustomSTM32WLx *)_radio)->isReceiving();
   }
diff --git a/src/helpers/radiolib/CustomSX1262Wrapper.h b/src/helpers/radiolib/CustomSX1262Wrapper.h
index cc7bb223..66f7adbf 100644
--- a/src/helpers/radiolib/CustomSX1262Wrapper.h
+++ b/src/helpers/radiolib/CustomSX1262Wrapper.h
@@ -20,6 +20,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomSX1262 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   bool isReceivingPacket() override { 
     return ((CustomSX1262 *)_radio)->isReceiving();
   }
diff --git a/src/helpers/radiolib/CustomSX1268Wrapper.h b/src/helpers/radiolib/CustomSX1268Wrapper.h
index 9ddea78f..b87e1cd6 100644
--- a/src/helpers/radiolib/CustomSX1268Wrapper.h
+++ b/src/helpers/radiolib/CustomSX1268Wrapper.h
@@ -20,6 +20,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomSX1268 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   bool isReceivingPacket() override { 
     return ((CustomSX1268 *)_radio)->isReceiving();
   }
diff --git a/src/helpers/radiolib/CustomSX1276Wrapper.h b/src/helpers/radiolib/CustomSX1276Wrapper.h
index 9d75ce12..cb073f91 100644
--- a/src/helpers/radiolib/CustomSX1276Wrapper.h
+++ b/src/helpers/radiolib/CustomSX1276Wrapper.h
@@ -19,6 +19,10 @@ public:
     updatePreamble(sf);
   }
 
+  bool setCodingRate(uint8_t cr) override {
+    return ((CustomSX1276 *)_radio)->setCodingRate(cr) == RADIOLIB_ERR_NONE;
+  }
+
   bool isReceivingPacket() override { 
     return ((CustomSX1276 *)_radio)->isReceiving();
   }
diff --git a/src/helpers/radiolib/RadioLibWrappers.h b/src/helpers/radiolib/RadioLibWrappers.h
index 9943bcab..07740234 100644
--- a/src/helpers/radiolib/RadioLibWrappers.h
+++ b/src/helpers/radiolib/RadioLibWrappers.h
@@ -40,6 +40,8 @@ public:
   }
 
   virtual void setParams(float freq, float bw, uint8_t sf, uint8_t cr) = 0;
+  uint16_t getDefaultPreambleLength() const override { return preambleLengthForSF(_preamble_sf); }
+  bool setPreambleLength(uint16_t len) override { return _radio->setPreambleLength(len) == RADIOLIB_ERR_NONE; }
   uint32_t getRngSeed();
   void setTxPower(int8_t dbm);
 
diff --git a/src/helpers/sensors/EnvironmentSensorManager.cpp b/src/helpers/sensors/EnvironmentSensorManager.cpp
index ea57677f..cfa215a4 100644
--- a/src/helpers/sensors/EnvironmentSensorManager.cpp
+++ b/src/helpers/sensors/EnvironmentSensorManager.cpp
@@ -8,6 +8,12 @@
 #define TELEM_WIRE &Wire  // Use default I2C bus for Environment Sensors
 #endif
 
+bool EnvironmentSensorManager::i2c_probe(TwoWire& wire, uint8_t addr) {
+  wire.beginTransmission(addr);
+  uint8_t error = wire.endTransmission();
+  return error == 0;
+}
+
 // ============================================================
 // Sensor library includes and static driver instances
 // ============================================================