Add GUI narrowband selector and responder negotiation for OFDM_NARROW

- Expand expert waveform dropdown from 3 to 5 items: AUTO, OFDM (OFDM_CHIRP),
  OFDM Narrow, OFDM HiSpeed (OFDM_COX), DPSK. "OFDM" now maps to OFDM_CHIRP
  (the recommended mode) instead of OFDM_COX.
- Add session-scoped narrowband_override_ to Connection so responder
  negotiateMode() picks OFDM_NARROW when narrowband chirp is detected,
  without requiring the initiator to send explicit preferred_mode.
  Override is cleared on disconnect/reset to avoid leaking to later sessions.
- Wire narrowband chirp detection to override in app.cpp, virtual station,
  and cli_simulator ping callbacks.
- Fix initiator narrowband: selecting OFDM Narrow in GUI now switches
  encoder to narrowband chirps via modem_.setNarrowbandControl(true).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: secup

src/gui/app.cpp

@@ -484,6 +484,10 @@ App::App(const Options& opts) : options_(opts), sim_ui_visible_(opts.enable_sim)
         } else {
             guiLog("MODEM: Detected PING/PONG (SNR=%.1f dB)", display_snr);
         }
+        // If narrowband chirp detected, set session-scoped override so negotiateMode() picks OFDM_NARROW
+        if (modem_.isNarrowbandDetected()) {
+            protocol_.setNarrowbandOverride(protocol::WaveformMode::OFDM_NARROW);
+        }
         protocol_.onPingReceived();
     });
     ultra::gui::startupTrace("App", "protocol-callbacks-mid6");
@@ -751,6 +755,8 @@ App::App(const Options& opts) : options_(opts), sim_ui_visible_(opts.enable_sim)
         protocol_.setPreferredMode(static_cast<protocol::WaveformMode>(waveform));
         protocol_.setForcedModulation(static_cast<Modulation>(modulation));
         protocol_.setForcedCodeRate(static_cast<CodeRate>(code_rate));
+        // Switch encoder chirps to narrowband when OFDM_NARROW is forced
+        modem_.setNarrowbandControl(waveform == static_cast<uint8_t>(protocol::WaveformMode::OFDM_NARROW));
         settings_.save();
     });
     ultra::gui::startupTrace("App", "settings-callbacks-exit");
@@ -760,6 +766,7 @@ App::App(const Options& opts) : options_(opts), sim_ui_visible_(opts.enable_sim)
     protocol_.setPreferredMode(static_cast<protocol::WaveformMode>(settings_.forced_waveform));
     protocol_.setForcedModulation(static_cast<Modulation>(settings_.forced_modulation));
     protocol_.setForcedCodeRate(static_cast<CodeRate>(settings_.forced_code_rate));
+    modem_.setNarrowbandControl(settings_.forced_waveform == static_cast<uint8_t>(protocol::WaveformMode::OFDM_NARROW));
     ultra::gui::startupTrace("App", "apply-expert-exit");
 
     // Apply initial filter settings from loaded config
@@ -1065,6 +1072,9 @@ void App::initVirtualStation() {
     // Wire up virtual modem ping detection to virtual protocol
     virtual_modem_->setPingReceivedCallback([this](float snr) {
         guiLog("SIM: Virtual modem detected PING/PONG (SNR=%.1f dB)", snr);
+        if (virtual_modem_->isNarrowbandDetected()) {
+            virtual_protocol_.setNarrowbandOverride(protocol::WaveformMode::OFDM_NARROW);
+        }
         virtual_protocol_.onPingReceived();
     });
 

src/gui/modem/modem_engine.cpp

@@ -616,6 +616,19 @@ std::vector<std::complex<float>> ModemEngine::getConstellationSymbols() const {
     return {};
 }
 
+bool ModemEngine::isNarrowbandDetected() const {
+    if (streaming_decoder_) {
+        return streaming_decoder_->getDetectedBandwidth() == BandwidthMode::NARROW;
+    }
+    return false;
+}
+
+void ModemEngine::setNarrowbandControl(bool narrowband) {
+    if (streaming_encoder_) {
+        streaming_encoder_->setNarrowbandControl(narrowband);
+    }
+}
+
 void ModemEngine::reset() {
     std::lock_guard<std::mutex> lock(rx_mutex_);
     std::queue<Bytes> empty;

src/gui/modem/modem_engine.hpp

@@ -129,6 +129,12 @@ class ModemEngine {
     using PingReceivedCallback = std::function<void(float measured_snr)>;
     void setPingReceivedCallback(PingReceivedCallback callback) { ping_received_callback_ = callback; }
 
+    // Check if last detected chirp was narrowband (valid after ping callback)
+    bool isNarrowbandDetected() const;
+
+    // Switch encoder to narrowband control chirps (for initiator forcing OFDM_NARROW)
+    void setNarrowbandControl(bool narrowband);
+
     void reset();
     void clearRxBuffer();  // Clear RX audio buffer (use before TX to prevent echo)
 

src/gui/widgets/settings.cpp

@@ -607,21 +607,25 @@ void SettingsWindow::renderExpertTab(AppSettings& settings) {
     ImGui::SetNextItemWidth(200);
 
     // Current waveform display string
-    const char* waveform_items[] = { "AUTO", "OFDM", "DPSK" };
+    const char* waveform_items[] = { "AUTO", "OFDM", "OFDM Narrow", "OFDM HiSpeed", "DPSK" };
     int waveform_idx = 0;  // AUTO
-    if (settings.forced_waveform == 0x00) waveform_idx = 1;       // OFDM
-    else if (settings.forced_waveform == 0x04) waveform_idx = 2;  // DPSK
+    if (settings.forced_waveform == 0x05) waveform_idx = 1;       // OFDM (OFDM_CHIRP)
+    else if (settings.forced_waveform == 0x06) waveform_idx = 2;  // OFDM Narrow
+    else if (settings.forced_waveform == 0x00) waveform_idx = 3;  // OFDM HiSpeed (OFDM_COX)
+    else if (settings.forced_waveform == 0x04) waveform_idx = 4;  // DPSK
 
-    if (ImGui::Combo("##waveform", &waveform_idx, waveform_items, 3)) {
+    if (ImGui::Combo("##waveform", &waveform_idx, waveform_items, 5)) {
         switch (waveform_idx) {
             case 0: settings.forced_waveform = 0xFF; break;  // AUTO
-            case 1: settings.forced_waveform = 0x00; break;  // OFDM
-            case 2: settings.forced_waveform = 0x04; break;  // DPSK
+            case 1: settings.forced_waveform = 0x05; break;  // OFDM (OFDM_CHIRP)
+            case 2: settings.forced_waveform = 0x06; break;  // OFDM Narrow
+            case 3: settings.forced_waveform = 0x00; break;  // OFDM HiSpeed (OFDM_COX)
+            case 4: settings.forced_waveform = 0x04; break;  // DPSK
         }
         changed = true;
     }
     ImGui::SameLine();
-    ImGui::TextDisabled("OFDM=fast, DPSK=robust");
+    ImGui::TextDisabled("OFDM=recommended, Narrow=low SNR, DPSK=robust");
 
     ImGui::Spacing();
 
@@ -696,8 +700,10 @@ void SettingsWindow::renderExpertTab(AppSettings& settings) {
 
     auto getWaveformStr = [](uint8_t w) -> const char* {
         switch (w) {
-            case 0x00: return "OFDM";
+            case 0x00: return "OFDM HiSpeed";
             case 0x04: return "DPSK";
+            case 0x05: return "OFDM";
+            case 0x06: return "OFDM Narrow";
             case 0xFF: return "AUTO";
             default: return "Unknown";
         }

src/protocol/connection.cpp

@@ -1041,6 +1041,7 @@ void Connection::enterDisconnected(const std::string& reason) {
     state_ = ConnectionState::DISCONNECTED;
     is_initiator_ = false;
     handshake_confirmed_ = false;
+    narrowband_override_ = WaveformMode::AUTO;  // Clear session-scoped narrowband override
     std::string old_remote = remote_call_;
     remote_call_.clear();
     pending_remote_call_.clear();
@@ -1160,6 +1161,7 @@ void Connection::reset() {
     timeout_remaining_ms_ = 0;
     connect_retry_count_ = 0;
     connected_time_ms_ = 0;
+    narrowband_override_ = WaveformMode::AUTO;  // Clear session-scoped narrowband override
     negotiated_mode_ = WaveformMode::OFDM_COX;
     remote_capabilities_ = ModeCapabilities::OFDM_COX;
     remote_preferred_ = WaveformMode::OFDM_COX;

src/protocol/connection.hpp

@@ -159,6 +159,10 @@ class Connection {
     void setPreferredMode(WaveformMode mode) { config_.preferred_mode = mode; }
     void setModeCapabilities(uint8_t caps) { config_.mode_capabilities = caps; }
 
+    // Session-scoped narrowband override (cleared on disconnect/reset)
+    // Set when responder detects narrowband chirp — overrides config_.preferred_mode for this session only
+    void setNarrowbandOverride(WaveformMode mode) { narrowband_override_ = mode; }
+
     // Forced data mode - operator can override SNR-based selection
     void setForcedModulation(Modulation mod) { config_.forced_modulation = mod; }
     void setForcedCodeRate(CodeRate rate) { config_.forced_code_rate = rate; }
@@ -229,6 +233,7 @@ class Connection {
     CodeRate pending_forced_code_rate_ = CodeRate::AUTO;
 
     // Waveform mode
+    WaveformMode narrowband_override_ = WaveformMode::AUTO;  // Session-scoped, cleared on disconnect/reset
     WaveformMode negotiated_mode_ = WaveformMode::OFDM_COX;
     uint8_t remote_capabilities_ = ModeCapabilities::OFDM_COX;
     WaveformMode remote_preferred_ = WaveformMode::OFDM_COX;

src/protocol/connection_handlers.cpp

@@ -510,6 +510,16 @@ WaveformMode Connection::negotiateMode(uint8_t remote_caps, WaveformMode remote_
         }
     }
 
+    // If narrowband chirp was detected this session, override for this connection
+    if (narrowband_override_ != WaveformMode::AUTO) {
+        uint8_t pref_bit = modeToBit(narrowband_override_);
+        if (common & pref_bit) {
+            LOG_MODEM(INFO, "Connection: Using narrowband override: %s",
+                      waveformModeToString(narrowband_override_));
+            return narrowband_override_;
+        }
+    }
+
     // If we have explicit preference, use it if remote supports it
     if (config_.preferred_mode != WaveformMode::AUTO) {
         uint8_t pref_bit = modeToBit(config_.preferred_mode);

src/protocol/protocol_engine.cpp

@@ -401,6 +401,11 @@ void ProtocolEngine::setModeCapabilities(uint8_t caps) {
     connection_.setModeCapabilities(caps);
 }
 
+void ProtocolEngine::setNarrowbandOverride(WaveformMode mode) {
+    std::lock_guard<ProtocolEngineMutex> lock(mutex_);
+    connection_.setNarrowbandOverride(mode);
+}
+
 void ProtocolEngine::setForcedModulation(Modulation mod) {
     std::lock_guard<ProtocolEngineMutex> lock(mutex_);
     connection_.setForcedModulation(mod);

src/protocol/protocol_engine.hpp

@@ -122,6 +122,9 @@ class ProtocolEngine {
     void setPreferredMode(WaveformMode mode);
     void setModeCapabilities(uint8_t caps);
 
+    // Session-scoped narrowband override (cleared on disconnect/reset)
+    void setNarrowbandOverride(WaveformMode mode);
+
     // Forced data mode - operator can override SNR-based selection
     // Set before calling connect(). Values are sent in CONNECT frame.
     // 0xFF (AUTO) = let responder decide based on SNR

tools/cli_simulator.cpp

@@ -592,11 +592,13 @@ class SimulatedStation {
         decoder_->setPingCallback([this](float snr_db, float cfo_hz) {
             last_cfo_hz_ = cfo_hz;
             // If narrowband chirp was detected, switch control waveform to narrowband
+            // and set session-scoped override so negotiateMode() picks OFDM_NARROW
             if (decoder_->getDetectedBandwidth() == BandwidthMode::NARROW) {
                 if (encoder_) {
                     encoder_->setNarrowbandControl(true);
                 }
-                LOG_MODEM(INFO, "[%s] Narrowband chirp detected, switching control waveform", callsign_.c_str());
+                protocol_.setNarrowbandOverride(WaveformMode::OFDM_NARROW);
+                LOG_MODEM(INFO, "[%s] Narrowband chirp detected, switching control waveform + narrowband override", callsign_.c_str());
             }
             protocol_.onPingReceived();
         });