feat(rate): handoff §6 second half — chirp-span physical samples close the trough gap (entry line carries channel X±Y at the pick; awgn@10 + good@10 PASS)

Every dual-chirp anchor contributes one channel sample (up-chirp span power
vs the frame's gap noise ref, >=3 dB anti-noise latch) — the entry cap now
has data even when the data span is in a fade null (F233's measured gap).
Residual: chirp convention reads ~+1.9 vs dial — folded into the filed §2
derivation test; the cap margin absorbs it.

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

Author: secup

docs/SNR_CALIBRATION_HANDOFF_2026_07_08.md

@@ -190,7 +190,14 @@ trough-zero wire reading (F233: "usable 0 dB" → boosted → R1/2, no physical
 sample at pick time) runs uncapped exactly where the boost is most dangerous.
 The chirp-accumulation half (this section's main spec) closes that: chirp
 |H|² samples have ~20 dB processing gain and measure cleanly inside data
-nulls. F233 also re-confirmed the mid-transfer dial-10 stall class
+nulls. **SHIPPED 2026-07-08 (second half): every dual-chirp anchor now
+contributes a physical sample (up-chirp span power vs the frame's gap noise,
+≥3 dB latch) — the entry line carries `channel X±Y` AT the pick (verified
+awgn@10 + good@10, both PASS, cap active at entry). RESIDUAL: chirp-referenced
+samples read ~+1.9 dB vs dial on AWGN (duty-factor + reference-convention
+detail) — fold into the §2 per-profile derivation test (derive
+10log10(P_chirp_span/P_ping_ref) from the generator, never tune by eye); the
+cap's 2.0 margin absorbs it until then.** F233 also re-confirmed the mid-transfer dial-10 stall class
 (rate thrash R1/2↔R2/3 riding fade epochs, then full-anchor-wait reject
 streak=1461 — the BUG-DECODE-BACKLOG/anchor family, pre-existing).
 

src/gui/modem/streaming_sync_acquisition.cpp

@@ -654,6 +654,53 @@ void StreamingDecoder::searchForSync() {
                 }
                 sync_noise_ref_rms_ = static_cast<float>(
                     std::sqrt(sum_sq / static_cast<double>(meas_end - gs - skip)));
+                // Handoff §6 second half (F233 trough gap): the CHIRP span is
+                // a channel power sample that survives fade nulls — the
+                // data-span physical correctly abstains in a trough (its
+                // anti-noise gate), which left the entry cap blind exactly
+                // where the affine boost is most dangerous (F233 entered off
+                // a wire-0 trough with an empty ring). Every dual-chirp anchor
+                // (PING, PONG, CONNECT, CONNECT_ACK) now contributes one
+                // sample: in-band power of the up-chirp span vs THIS frame's
+                // gap noise ref, latched only ≥3 dB above it (a false lock on
+                // noise reads ~0 and is refused). Convention: chirp-referenced
+                // ≈ dial within ~1 dB (the reference power is chirp-dominated;
+                // the ring's consumers carry a 2 dB margin).
+                if (sync_result.preamble_start_sample >= 0 &&
+                    sync_noise_ref_rms_ > 0.0f) {
+                    const size_t cs = std::min(
+                        static_cast<size_t>(sync_result.preamble_start_sample),
+                        search_buffer.size());
+                    const size_t clen = std::min(
+                        static_cast<size_t>(sync_result.interchirp_gap_start_sample >
+                                                sync_result.preamble_start_sample
+                                            ? sync_result.interchirp_gap_start_sample -
+                                                  sync_result.preamble_start_sample
+                                            : 0),
+                        search_buffer.size() - cs);
+                    if (clen > 4800) {  // >=0.1 s of chirp
+                        FIRFilter chirp_filter =
+                            FIRFilter::bandpass(101, 50.0f, 2950.0f, 48000.0f);
+                        const size_t skip = clen / 10;
+                        for (size_t i = cs; i < cs + skip; ++i) {
+                            chirp_filter.process(search_buffer[i]);
+                        }
+                        double sum_sq = 0.0;
+                        for (size_t i = cs + skip; i < cs + clen; ++i) {
+                            const float y = chirp_filter.process(search_buffer[i]);
+                            sum_sq += static_cast<double>(y) * y;
+                        }
+                        const double p_c =
+                            sum_sq / static_cast<double>(clen - skip);
+                        const double p_n =
+                            static_cast<double>(sync_noise_ref_rms_) *
+                            static_cast<double>(sync_noise_ref_rms_);
+                        if (p_n > 0.0 && p_c > 2.0 * p_n) {
+                            notePhysicalSnrSample(static_cast<float>(
+                                10.0 * std::log10((p_c - p_n) / p_n)));
+                        }
+                    }
+                }
                 // Handoff §2: hand THIS frame's burst-time noise reference to
                 // the waveform so its training-span decode computes the
                 // physical channel SNR (per-frame — no stale latch).