aethersdr
diff --git a/‎src/models/RadioModel.cpp‎
Lines changed: 32 additions & 4 deletions b/‎src/models/RadioModel.cpp‎
Lines changed: 32 additions & 4 deletions
diff --git a/‎tests/icom_family_test.cpp‎
Lines changed: 79 additions & 0 deletions b/‎tests/icom_family_test.cpp‎
Lines changed: 79 additions & 0 deletions
@@ -1480,10 +1480,38 @@ void RadioModel::setupBackend(const QString& family)
     // healthSnapshot() honestly.
     //
     // Free on the constructor's own call, where TransmitModel is at its 50 and
-    // 50 maps to the 1.0 the modulator already holds. Same Flex gate as the
-    // seam: on a Flex the slider's `transmit set miclevel=` reaches the radio's
-    // own preamp and this must not double it.
-    if (m_backend && !usesFlexCommandPlane())
+    // 50 maps to the 1.0 the modulator already holds.
+    //
+    // GATED ON hostModulates, NOT on the family predicate the operator-intent
+    // seam uses — the two sites ask different questions and the gate was copied
+    // between them.
+    //
+    // The seam's gate is DE-DUPLICATION: setMicLevel() emits
+    // `transmit set miclevel=` beside micLevelCommandIssued, so on a Flex the
+    // seam would issue a second copy of a command the wire text already carried.
+    // Nothing is in flight here. setupBackend() emits no wire text, so "did the
+    // Flex text path already carry this" is not a question this site has.
+    //
+    // The question this site has is whether the fresh backend HAS a host
+    // modulator standing at its own default, waiting to be told where the
+    // operator left the slider. That is precisely what hostModulates answers.
+    // A backend that does not host-modulate has no such object: it either has
+    // nothing to seed (Flex, RTL, the sim) or it owns the value INSIDE the radio
+    // and will report it on connect — Icom, where IRadioBackend::setMicGain is
+    // implemented as a live CI-V 14 0B write (or, on an IC-9700 with LAN as the
+    // modulation input, a SET 0114 LAN MOD write). Handing either one a
+    // client-held number at construction is a silent write of state the radio
+    // never asked for, and it marks the backend's own mirror as reported —
+    // healthSnapshot() then prints our number where the radio's belongs, before
+    // a single 14 0B reply has arrived. The operator's own slider move still
+    // reaches an Icom through micLevelCommandIssued; only this construction-time
+    // push stops.
+    //
+    // See the hostModulates declaration in RadioCapabilities.h, which carries
+    // the warning that conflating it with takesTxAudioOverSeam cost a working
+    // transmitter. This is that same flag, read for the question it was written
+    // to answer: does the HOST run the modulator.
+    if (m_backend && backendCapabilities().hostModulates)
         m_backend->setMicGain(m_transmitModel.micLevel());
 }
 
 
@@ -10,6 +10,7 @@
 // written, tested and green while nothing in the application could construct it.
 
 #include "models/RadioModel.h"
+#include "models/TransmitModel.h"
 #include "core/RadioDiscovery.h"
 #include "core/backends/icom/IcomCivBackend.h"
 #include "core/backends/icom/IcomControls.h"
@@ -49,6 +50,21 @@ struct IcomCivBackendTestAccess {
         backend.m_connected = true;
         backend.onCivFrame(frame, backend.m_sessionGeneration);
     }
+
+    // The mic-gain mirror, which setMicGain() writes BEFORE sendUserCommand()
+    // decides whether a frame can go out. It is therefore the honest witness to
+    // "did this backend take the value at all" on a backend that has no session
+    // yet: the CI-V write is dropped by the not-connected guard, but the mirror
+    // is already dirty, and healthSnapshot() publishes it as the radio's own.
+    static bool micGainReported(const IcomCivBackend& backend)
+    {
+        return backend.m_micGainReported;
+    }
+
+    static int micGainPercent(const IcomCivBackend& backend)
+    {
+        return backend.m_micGainPercent;
+    }
 };
 
 } // namespace AetherSDR::icom
@@ -806,6 +822,69 @@ int main(int argc, char** argv)
               "and neither is a different sub-command");
     }
 
+    // ── The construction-time mic push stops at a radio that owns its mic gain ──
+    //
+    // RadioModel::setupBackend() hands a freshly built backend the mic level
+    // the model already holds, so a host modulator constructed at its own unity
+    // default cannot silently part from the slider (pinned from the other side
+    // by hl2_family_transition_test). That push is gated on
+    // caps.hostModulates, and this is the family it exists to exclude.
+    //
+    // On an Icom the mic level is not a client-side DSP gain at all: it is the
+    // radio's own 14 0B MIC GAIN register — or, on an IC-9700 with LAN as the
+    // modulation input, SET 0114 — read back on connect and mirrored into the
+    // same slider (IcomControls: "mic.gain", Wiring::Both). A backend rebuild
+    // is not the operator asking for anything, so pushing a number carried in
+    // from the previous radio is a silent write of state this radio never asked
+    // for. The wire itself is defended by sendUserCommand()'s not-connected
+    // guard, but the mirror is written before that guard is reached, and
+    // healthSnapshot() then prints our number where the radio's belongs.
+    //
+    // Break it by restoring the !usesFlexCommandPlane() gate at the end of
+    // setupBackend() and the first check below fails with the mirror reporting
+    // 80 on a radio that has answered nothing.
+    {
+        // Away and back, because connectToRadio() rebuilds only on a family
+        // CHANGE — a same-family reconnect keeps the backend it already has.
+        model.connectToRadio(infoFor(QStringLiteral("flex"),
+                                     QStringLiteral("1234-5678-9012-3456")));
+        // Where the operator left the slider on the PREVIOUS radio. The model is
+        // never reset across a family switch, which is what makes this a value
+        // that can travel. Set while Flex is live, where the seam is silent and
+        // `transmit set miclevel=` is the wire form.
+        model.transmitModel().setMicLevel(80);
+        model.connectToRadio(infoFor(QStringLiteral("icom")));
+        auto* rebuilt = dynamic_cast<icom::IcomCivBackend*>(model.backend());
+        check(rebuilt != nullptr, "the family switch produced a fresh Icom backend");
+        if (rebuilt) {
+            check(!icom::IcomCivBackendTestAccess::micGainReported(*rebuilt),
+                  "a rebuilt Icom backend is not handed the previous radio's mic "
+                  "level: the radio owns 14 0B and has not been asked yet");
+
+            // AND THE OPERATOR'S OWN HAND STILL REACHES IT. This narrows the
+            // construction push only; micLevelCommandIssued is operator intent
+            // and stays wired, so the Phone MIC slider remains a live control on
+            // an Icom rather than a readout that cannot write back.
+            // WHY THIS LANDS IN THE PHYSICAL-MIC BRANCH, since the answer is not
+            // local: IcomCivBackend's constructor seeds m_model to
+            // unknownModel(), whose civAddress matches no case in profileFor(),
+            // so modulationProfileFor() is nullopt and setMicGain() never takes
+            // its LAN-MOD early return. An unidentified Icom has no modulation
+            // profile, so this is the 14 0B path.
+            //
+            // It matters for the NEXT reader rather than for today: if
+            // unknownModel() ever gained a profile with
+            // phoneLevelFollowsNetworkInput, this would fail on the
+            // m_networkModLevelPercent < 0 refusal — a reason that has nothing
+            // to do with the gate this section pins (PR #5643 review).
+            model.transmitModel().setMicLevel(70);
+            check(icom::IcomCivBackendTestAccess::micGainReported(*rebuilt)
+                      && icom::IcomCivBackendTestAccess::micGainPercent(*rebuilt)
+                             == 70,
+                  "the operator moving the slider still reaches the Icom mic gain");
+        }
+    }
+
     if (g_failures == 0)
         std::printf("icom_family_test: all checks passed\n");
     return g_failures == 0 ? 0 : 1;