feat(arq): keepalive ACK — break the marginal-SNR anchor-wait no-ACK stall (ULTRA_KEEPALIVE_ACK, default off)

BUG-ANCHOR-WAIT-NO-ACK-STALL: at marginal SNR, burst heads (corr 0.15-0.32)
fall below the sync weak_accept floor (~0.45) → rejected in full-anchor-wait →
NO ACK emitted → sender waits the full 44.68 s RTO. MPG@25 batch measured this
as the top throughput drag (~+30% prize).

Fix: the receiver re-emits its current cumulative ACK when its ACK side has
gone silent > 25 s during an active file receive (rx_base_seq_>0 &&
last_rx_more_data_). The sender resends holes on ANY tone-burst ACK (turn
boundary), so a re-ACK converts the 44 s RTO into a fast turnaround (~19 s
saved/stall). No new protocol; routes through listen-before-ACK gating.

Threshold 25 s > max burst airtime (window-16 ≈ 21.5 s) so it only fires on a
genuine stall, not mid-legit-burst — no channel-busy plumbing needed for v1.
v2 (filed): channel-gated shorter threshold for a bigger saving.

Verified: ctest 86/86 (default-off byte-identical); sim good@20 PASS 2770.
Rig A/B at MPG@25 next (the stall is a marginal-SNR phenomenon the sim can't
reproduce).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019btwFxDt7D19SZSqPYvZnk

Author: secup

src/protocol/connection.cpp

@@ -4413,6 +4413,25 @@ void Connection::tick(uint32_t elapsed_ms) {
             }
 
             arq_.tick(elapsed_ms);
+
+            // KEEPALIVE ACK (BUG-ANCHOR-WAIT-NO-ACK-STALL, ULTRA_KEEPALIVE_ACK,
+            // default off): break the 44 s RTO stall when marginal bursts get
+            // rejected at sync (no ACK emitted) during an active file receive.
+            // Threshold 25 s > max burst airtime (window-16 ≈ 21.5 s) so it
+            // only fires on a genuine stall (no burst completed in the window),
+            // not mid-legit-burst — no channel-busy gating needed for v1. Fires
+            // before the 44.68 s RTO, saving ~19 s/stall. The re-emitted ACK
+            // routes through listen-before-ACK; the sender resends holes on any
+            // tone-burst ACK (turn boundary). v2 (filed): channel-gated shorter
+            // threshold for a bigger saving.
+            static const bool keepalive_ack_enabled = [] {
+                const char* e = std::getenv("ULTRA_KEEPALIVE_ACK");
+                return e != nullptr && e[0] != '\0' && e[0] != '0';
+            }();
+            if (keepalive_ack_enabled) {
+                arq_.keepaliveAckIfStalled(25000u);
+            }
+
             // RX-AUTHORITY: age the verdict-SNR ring (stale readings must not
             // steer the rung after a quiet stretch).
             for (size_t i = 0; i < kRxAuthObsRing; ++i) {

src/protocol/selective_repeat_arq.cpp

@@ -1368,6 +1368,7 @@ void SelectiveRepeatARQ::handleNackFrame(const v2::ControlFrame& frame) {
 
 void SelectiveRepeatARQ::tick(uint32_t elapsed_ms) {
     arq_time_ms_ += elapsed_ms;
+    keepalive_silent_ms_ += elapsed_ms;  // reset on each sendSack() emit
 
     if (ack_dedup_timer_ms_ > 0) {
         if (elapsed_ms >= ack_dedup_timer_ms_) {
@@ -2044,6 +2045,19 @@ size_t SelectiveRepeatARQ::bufferedRxFrameCount() const {
     return count;
 }
 
+bool SelectiveRepeatARQ::keepaliveAckIfStalled(uint32_t threshold_ms) {
+    if (!(rx_base_seq_ > 0 && last_rx_more_data_ &&
+          keepalive_silent_ms_ >= threshold_ms)) {
+        return false;
+    }
+    LOG_MODEM(INFO,
+              "SR-ARQ: keepalive ACK — receiver silent %u ms during active RX "
+              "(base=%u, stall recovery)",
+              keepalive_silent_ms_, rx_base_seq_);
+    sendSack();  // re-emit current cumulative state; resets keepalive_silent_ms_
+    return true;
+}
+
 void SelectiveRepeatARQ::sendSack() {
     // MOVE-EPOCH: TOTAL ack silence while unanchored — rx_base_seq_ is still an
     // old-era number, so ANY cumulative claim built from it would fabricate
@@ -2056,6 +2070,8 @@ void SelectiveRepeatARQ::sendSack() {
         return;
     }
 
+    keepalive_silent_ms_ = 0;  // we are emitting an ACK now → not silent
+
     uint32_t bitmap = buildRXBitmap();
     uint16_t base_seq = (rx_base_seq_ - 1) & 0xFFFF;
     const bool sack_has_final = rx_final_delivered_since_sack_;

src/protocol/selective_repeat_arq.hpp

@@ -192,6 +192,16 @@ class SelectiveRepeatARQ : public IARQController {
     }
     size_t getWindowSize() const { return config_.window_size; }
     uint16_t getRxBaseSeq() const { return rx_base_seq_; }
+
+    // Keepalive ACK (BUG-ANCHOR-WAIT-NO-ACK-STALL, 2026-07-14): when we are
+    // actively receiving a file (more frames expected) but our ACK side has
+    // gone silent for threshold_ms — bursts arriving yet rejected at sync
+    // (marginal corr) or failing before decode, so no SACK was emitted — we
+    // re-emit the current cumulative ACK. The sender treats ANY tone-burst ACK
+    // as a turn boundary and resends the holes immediately, converting a full
+    // 44 s RTO stall into a fast turnaround. Routes through the normal
+    // listen-before-ACK channel gating. Returns true if a keepalive was sent.
+    bool keepaliveAckIfStalled(uint32_t threshold_ms);
     uint16_t getTxBaseSeq() const { return tx_base_seq_; }
     // HARQ provisional keys (2026-07-01): the receiver's mirror of the
     // sender's next-burst seq fill = ascending !received seqs in the rx
@@ -389,6 +399,7 @@ class SelectiveRepeatARQ : public IARQController {
     // RX state
     std::array<RXSlot, MAX_WINDOW> rx_window_;
     uint16_t rx_base_seq_ = 0;      // Next expected sequence
+    uint32_t keepalive_silent_ms_ = 0;  // ms since last SACK emit (stall detect)
     bool last_rx_more_data_ = false;
     uint8_t last_rx_flags_ = 0;
     v2::FrameType last_rx_frame_type_ = v2::FrameType::DATA;