[jcmerg]

Summary

A Hermes-Lite 2 stores no settings at all, so the client has to be its memory. These HL2 settings were lost on every restart:

Setting	Where it is kept now
TUNE power	OperatingState.ext.txSetpoints.tuneByBand, per band, with a first-set baseline tuneDefaultPercent (same rule as drive)
FFT AVG / Wt Avg	the existing per-radio ClientDisplay.fftAverages table. The HL2 now declares BackendPanAveraging::clientPersistsAveraging
Receivers B, C, D (#5777)	new Receivers domain: ext.receivers, receiver A first, with the transmit receiver marked
Each receiver's NB/NB2 (kind, level, fill), APF, squelch, RIT/XIT, audio gain/pan, pan centre	the same receivers entries
Manual notches	new Notches domain: ext.notches (centre, width, active)
Auto RF gain law and floor	ext.rfGain.autoLaw / autoFloorDb, written only when the operator chose them

Before this PR, RF drive, LNA, frequency, mode, passband, AGC, mic level and CW were already kept. FFT FPS and the dBm range are kept since #6140.

#5777 needs a ruling first. on8st asked the maintainers there whether an HL2 should restore its receiver set, and nobody has answered yet. This PR implements the answer proposed in that thread: no persisted count, because #4545's reason still holds. Each receiver's own state is stored instead, and after link-up those receivers are reopened through createPanadapter()'s own add path, so receiverCeiling() at the current span still decides how many come back. If the ruling is no, the Receivers part can come out on its own. The rest of the PR does not depend on it.

Design

• Seam: setTunePower(). RadioModel now also forwards a TUNE power change while unkeyed, to a backend that declares tunePowerAppliesLive. HL2 records it per band. Icom already returns early when !m_tuning, so Icom behaviour is unchanged. A TUNE decoded off the radio, i.e. not keyed by this client, still forwards nothing, and the drop-notice logic is untouched. Contract comment updated in IRadioBackend.h.

• Replay. connectRadio() arms m_sessionReplayPending. The linkUp handler runs replayRestoredSession() once, after receiver A is published:

  1. notches through createNotch() (fresh ids, markers reach TnfModel);
  2. receivers through addReceiver(seed). createPanadapter() is now addReceiver() with a seed copied from A, so the operator's path and the replay share one code path;
  3. transmit back to its receiver through setTxSlice(). That is ownership only, never a key.
  4. if the ceiling (or a failed open) cuts the replay short, the receivers that did not come back are kept (m_replayUnreopened) and captured after the live ones, so a later connect with room still has them. They are dropped once the operator adds or closes a receiver.

  A linkUp after EP6 silence replays nothing. If an explicit numRx param already opened receivers, the replay starts after them.

• Receivers opened at connect take their own entries (seedOpenReceiversFromMemory): receiver A its extras, and any receiver an explicit numRx param opened its whole entry.

• Receiver A takes its extras (blanker, APF, squelch, RIT/XIT, audio, pan centre) in connectRadio(), under the same "new radio or rebuilt receivers" condition as seedReceiverAgc(). A plain reconnect keeps the live values. A's frequency, mode and passband come from its own entry rather than the flat fields, because the flat fields follow the TX receiver.

• AGC stays flat, as seedReceiverAgc() documents. It is not stored per receiver.

• Validation (Principle VII). Each field is checked on its own and a bad value falls to its default, never clamped. An entry with no usable frequency or mode ends the list, so C never moves into B's slot. restorableRfHz() and restorablePassband() are now the one rule for the flat fields and the entries alike.

• Gating. RadioStateMemory gates the extension through one table, gateExtension(), shared by load() and store(). A backend that does not declare Receivers or Notches never sees those keys. No schema bump: the contents of the extension sub-objects belong to the backend, and an older build simply drops the new keys on its next write.

• Capture before the replay keeps the remembered lists. store() rebuilds the whole document, so otherwise they would be erased.

• NB echo. emitSliceState() publishes the blanker once after a restore (nbEchoPending), not on every echo, because SliceModel::applyChanges() re-emits all three NB signals unconditionally.

• TUNE power under a carrier. A band change under a TUNE carrier does not apply band memory; the carrier keeps running at the value the slider shows, and the new band's own value applies at unkey.

• SWR sweep now restores TUNE power before the frequency, so a per-band radio records it on the swept band.

Evidence

Unit tests (local, macOS 26, Qt 6.12.0). New: hl2_session_memory_test, 14 cases, injected link edge, no socket. Updated: transmit_seam_drop_notice_test for the widened forwarding. All green: hl2_session_memory_test, transmit_seam_drop_notice_test, hl2_state_restore_test, hl2_pan_create_async_test, hl2_backend_session_scope_test, hl2_auto_gain_law_test, radio_state_memory_test, hl2_backend_seam_test, hl2_tx_gate_test, hl2_gain_restore_test. Static checks run locally: check_capability_records, check_ci_test_gate, check_command_plane, check_engine_boundary, check_network_timeouts, check_qsettings, check_test_registration, gen_seam_probe_table --check, gen_touchpoint_manifest --check. All green.

Mutations. Each guard was broken, the test run, then restored:

Mutation	Result
no replayRestoredSession() at link-up	red: "receivers B and C are reopened" (+7)
replay starts at 1 instead of the running count	red: "the replay adds only the third"
band memory applied under a TUNE carrier	red: "a band change under a TUNE carrier echoes no other TUNE power"
nbEchoPending never cleared	red: "the restored blanker is published once"
no TX restore	red: "transmit is back on receiver B" (+1)
clientPersistsAveraging false	red: "the HL2 makes the client the owner of FFT AVG and Wt Avg"
Receivers missing from the extension gate	red: "declared, both lists round-trip through the store"
capture ignores the pending replay	red: "the remembered notch is kept"
setTunePower() does not record	red: "back on 40 m, its own TUNE power is echoed" (+3)
RadioModel forwards only to a live carrier (old gate)	red: "setTunePower(25) reaches the backend to be recorded" (+1)
RadioModel forwards under a decoded TUNE	red: "no setTunePower() reaches the backend"
a bad entry is skipped, not list-ending	red: "C does not move into B"
law choice not written	red: "a chosen law and floor are written" (+2)
replay forgets the receivers it could not reopen	red: "the receivers that did not fit are still in the document"
an operator close keeps that tail	red: "once the operator reshapes the set, the kept tail is dropped"
no TUNE memory at unkey	red: "at unkey the new band's own TUNE power applies"
only receiver A seeded at connect	red: "the receiver the connect opened takes its own remembered entry"
receiver A seeded on every connect	red: "a reconnect of the same radio keeps receiver A's live blanker" (connectRadio() twice, same serial)

Hardware: a Hermes-Lite 2, gateware reporting 4 receivers, CL1 on an external 10 MHz. Driven through the automation bridge, with a normal quit and relaunch, and checked with get slices, get transmit, notch list, get display, health and the OperatingState row:

• Run 1: A 7.1896 LSB with NB2 70, SQL on 33 and RIT +20; B 14.074 DIGU with NB 40; two notches; TUNE power 37; FFT AVG 45 on pan 1; auto RF gain law ramp, floor 12. All of it came back after relaunch, and B came back with AGC off in DIGU. Log: HL2 restore: … tune bands 1 receivers 2 notches 2, added receiver — DDC 1 … running 2 of 4.
• Run 2, after the review fixes: TX moved to B on 20 m, TUNE power 23. After relaunch TX was on B (transmit moves from DDC 0 to 1) with TUNE power 23.
• Nothing was keyed in either run.

Not verified:

• APF on hardware (the control is hidden in LSB; covered by the unit test).
• A replay that hits the receiver ceiling on hardware (unit test only).
• A sweep that ends with preserveBandSwitchOnFinish, or is aborted by a disconnect. The sweep power can then still be recorded for the swept band, because the seam cannot tell a sweep's TUNE power from the operator's.

Not kept, on purpose: the global notch bypass (session state; TnfModel::clear() resets it on disconnect and no seam signal echoes it back); per-receiver AGC (flat by design). Auto SQL mode is the applet's, and only the backend squelch pair is stored.

CHANGELOG.md untouched. rtl_wfm_pipeline_test fails to link locally with RtlSdrDdc symbols missing. This PR touches nothing on that path.

[aethersdr-agent]

Reviewed at 4653edf against the PR head checkout. All five checks are green on that SHA (build, check-windows, check-macos, Static checks, Sanitizer option configures) — noting as always that every ctest call in ci.yml is -R-filtered, so green is not "the suite passed".

1. Issue fit

There is no Fixes line. The body references #5777 (receivers B/C/D not persisted) and implements the answer on8st proposed there; the TUNE power, FFT AVG, notch and auto-gain-law parts have no linked issue and stand on Principle III ("a radio that stores nothing makes the client its memory"). I read #5777 and its full thread: the triage agent and on8st both asked for a ruling (09-30, re-asked 10-04), the issue still carries maintainer-review, and no maintainer has answered. The body is honest about this. So: the non-Receivers work is reviewable on its merits and solves what it claims; the Receivers domain is a correct implementation of an unratified decision — see the recommendation.

Each claim I could test from source held. One I checked specifically because it is the headline of the FFT AVG row: flipping clientPersistsAveraging really does engage an existing, working path — MainWindow_Wiring.cpp:3206-3221 (save) and :3296-3306 (restore) are both gated on shapesDisplayRatesLocally() && clientPersistsAveraging, which is true for the HL2, and Hl2Backend::emitPanState (:8446-8459) emits only centre/bandwidth, so pan->average() stays -1 and the disk branch is actually reached rather than losing to a live model value. Single save site, single restore site, one key — no second owner, so Constitution V holds.

2. Scope

File(s)	What it changes	Claimed in the body?	Verdict
src/core/backends/hl2/Hl2Backend.{h,cpp}	TUNE-power band memory, Receivers/Notches capture + replay, createPanadapter()→addReceiver(seed), auto-gain law/floor persistence, nbEchoPending	yes	in scope
src/core/backends/RadioCapabilities.h	two new ClientSettingsDomain bits (Receivers, Notches)	yes	in scope — new maintainer-visible surface (see below)
src/core/RadioStateMemory.cpp	gateExtension() table shared by load()/store()	yes	in scope; a genuine de-duplication of the PR #4614 gate
src/core/backends/IRadioBackend.h	setTunePower() contract comment only	yes	in scope
src/models/RadioModel.cpp	widened tunePowerCommandIssued gate + comment	yes	in scope
src/gui/MainWindow_SwrSweep.cpp	restore TUNE power before the frequency	yes	in scope, and necessary — see §5
docs/HERMES.md, docs/architecture/radio-capabilities-map.md	the two caps rows + the receiver-count paragraph	yes	in scope; the caps-map row is the required doc half of a capability change
tests/hl2_session_memory_test.cpp, tests/tests.cmake	new 13-case test, registered at tests.cmake:1584-1587	yes	in scope
tests/transmit_seam_drop_notice_test.cpp	widened for the new forwarding	yes	in scope

Nothing in the diff is unexplained by the body. No CHANGELOG.md entry (correct). No socket, no fake peer, no Fake* radio class added — I grepped the PR's own test source for QTcpServer/QUdpSocket/bind(/listen(/connectToHost/Fake and it is empty, so there is nothing to disclose on that axis.

For the maintainer to rule on, not a violation: two new ClientSettingsDomain flags, and six new keys inside the HL2-owned ext sub-objects (txSetpoints.tuneByBand, tuneDefaultPercent, rfGain.autoLaw, autoFloorDb, plus the receivers and notches arrays) with no extensionSchemaVersion bump. The no-bump reasoning holds on inspection: store() rebuilds ext from scratch, so an older build simply drops keys it does not write rather than leaving a half-migrated document, and an absent array restores today's behaviour. These are not protocol surface and not third-party-visible. The capability ratchet is unaffected — it counts bools, and these are enum bits.

3. Blockers

1. src/core/backends/hl2/Hl2Backend.cpp:7139 — a truncated replay erases the receivers that did not come back, permanently.

        if (!addReceiver(seed)) {
            qCInfo(lcHl2) << "HL2 restore:" << (m_restoredReceivers.size() - i)
                          << "remembered receiver(s) not reopened";
            break;
        }

replayRestoredSession() clears the guard flag on its first line (:7116, m_sessionReplayPending = false;) and only then opens receivers. Each successful addReceiver() ends with notifyOperatingStateChanged() (:1077), which reaches RadioModel::scheduleOperatingStateSave() — and isConnected() is already true, because emit connected() ran at :501 before the replay. So the debounced store lands a moment after the loop with m_sessionReplayPending == false and m_rx holding only the receivers that fit. In currentOperatingState() the protective branch

    // Same for the receivers while none are running or B.. are not yet back.
    if (m_rx.empty() || m_sessionReplayPending) {

(:7276-7284) cannot fire — the flag it tests was cleared before the first add — so receivers is rebuilt from the short live list and the remainder is gone from disk. The next connect, even one with room, has nothing to restore.

Failure scenario, reasoned from code rather than run: a skimmer board (m_boardMaxRx 9-12) with six receivers stored. The operator next connects by IP, the unicast discovery probe at :2331-2342 is dropped or answers short, and :2350 falls back to m_boardMaxRx = kAssumedBoardMaxRx (4). The replay reopens four, logs 2 remembered receiver(s) not reopened — and the capture it just triggered rewrites receivers with four entries. The two skimmer receivers are not recoverable. The same erasure follows any openReceiverDsp() failure mid-replay (:1052, WDSP channel pool), which also returns false into this break.

On a shipping 4-RX board with a self-consistent span this will not fire: I checked that applyPanBandwidth refuses a zoom the running receivers cannot carry (:3790-3800), so a stored (count, span) pair is normally reachable again. That is what keeps this out of the common path — not the code.

The fix is a judgment call rather than a one-liner, because the tail must not be kept after an operator close (removePanadapter) or the capture would resurrect a receiver they deliberately shut. The shape I would suggest: have the replay record what it could not open — e.g. a std::vector<Receiver> m_replayUnreopened filled from m_restoredReceivers.begin() + i at the break — append it to receivers in currentOperatingState(), and clear it in removePanadapter() and in addReceiver() once the operator adds one back. The doc sentence this PR adds ("the receiver ceiling at the current span still decides how many return") then becomes true across sessions, which is what it currently implies and does not deliver.

The test that would have caught it is already most of the way there — tests/hl2_session_memory_test.cpp:355-367 asserts the surviving count equals Access::ceiling(backend) but never re-reads currentOperatingState() afterwards. One extra check on the stored array size in that case pins the fix.

4. Nits (non-blocking)

• src/core/backends/hl2/Hl2Backend.cpp:5226 — TUNE power goes stale after a band change under the carrier, and the next key-down overwrites the new band's memory. applyTuneMemoryFor() correctly refuses while m_tuning (if (m_tuning || tune < 0 || tune == m_tunePowerPercent) return;), and the test pins that refusal — but nothing re-applies on unkey. Keyed TUNE on 40 m at 30 → QSY to 20 m (remembered 55) → unkey: the slider still reads 30, and the next TUNE records 30 over 20 m's 55 via recordTunePower() at :5171. Drop-in, in the unkey branch at :5181-5183:

    } else {
        setKeying(false, operation, completion);   // clears m_tuning and restores the operator's RF power
        setTxTestTone(0.0, 0.0, operation);
        // A band change under the carrier left the new band's own TUNE power
        // unapplied (applyTuneMemoryFor refuses while m_tuning). The carrier is
        // down now, so bring it back — otherwise the next key-down runs, and
        // records, the previous band's value on this band.
        applyTuneMemoryFor(m_currentBandKey);
    }

• src/core/backends/hl2/Hl2Backend.cpp:7137 — a numRx > 1 connect leaves the pre-opened receivers without their remembered setpoints. The replay loop starts at m_rx.size(), which is the documented intent, but only receiver A gets seedFirstReceiverFromMemory() (:2407). With numRx=2 from automation, receiver B comes up on A's inherited state and its remembered blanker/APF/squelch/RIT/audio are silently skipped — then captured over. Automation-only, so low severity; worth a sentence in the comment at minimum.

• src/core/backends/hl2/Hl2Backend.cpp:7268-7275 (notches) / :7284 (receivers) — asymmetric emptiness. notches is always inserted (an empty array is written); receivers is inserted only when non-empty. Both are harmless given gateExtension(), but the asymmetry will read as accidental to the next person.

• tests/hl2_session_memory_test.cpp:191 — receiver A's extras are exercised by calling the private seed directly (Access::seedFirstReceiver), not through connectRadio(). The seed function itself is well covered; what is not covered anywhere is the gate that decides whether it runs (request.serial != m_agcSeededSerial || !m_rxCarriedState, :2404), i.e. the "plain reconnect keeps the live values" half of the design. Hardware run 1 covered the positive case.

5. What I tried to break (and could not)

• Sibling setTunePower() implementations. The widened RadioModel gate (RadioModel.cpp:2216-2225) now forwards unkeyed to any backend declaring tunePowerAppliesLive. Only two declare it — HL2 (Hl2Backend.cpp:1910) and Icom (IcomCivBackend.cpp:376); ANAN and Flex are explicitly false, and IcomCivBackend::setTunePower (:5117) returns early when not tuning. So no backend gains an unkeyed drive write, and the decoded-TUNE refusal case in transmit_seam_drop_notice_test is correctly left unmodified (isTuning() && !tuneCarrierLive() still returns). No Principle VI exposure here.
• The m_rx[i] == DDC i assumption that both the transmit flag (:7259, i == m_txDdc) and the replay's m_ids.byDdc(m_restoredTxReceiver) rest on. rx(ddc) is &m_rx[ddc] (:765), and removePanadapter() compacts: m_rx.erase(begin()+ddc) plus m_ids.remove(ddc) renumbers, with m_txDdc and m_activeDdc moved explicitly (:1313-1329). A middle close does not strand the TX flag. The A+B-only hardware run did not cover this; the code does.
• An echo loop on TUNE power. applyTuneMemoryFor() assigns m_tunePowerPercent before emitting, so a TransmitModel round trip back through setTunePower() hits recordTunePower()'s equality guard and dies there. No oscillation and no spurious band write.
• The SWR sweep reorder. My first read was that it moves the record onto the wrong band, so I checked what the sweep spans: MainWindow_SwrSweep.cpp:312-344 confines a sweep to the current band and :162 aborts it on a band change, so swept band == original band and restoring the power before the frequency is both safe and the only ordering that records the operator's value on the right band. The aborted-by-disconnect leak is real and the body already discloses it.
• A stale overwrite on disconnect. flushPendingOperatingState only writes when a timer is pending, and emit disconnected() fires from the linkDown handler (:495-501) with m_rx intact — disconnectRadio() routes through the same place (:2842) — so the flush captures the live receivers, not the connect-time m_restoredReceivers. The m_rx.empty() fallback in currentOperatingState() is genuinely for the torn-down case.
• The gating negative. hl2_session_memory_test.cpp:491-496 clears the Receivers bit and asserts the list is withheld on load, so the new domains have the gating test the capability contract asks for, not just the declaration and the doc row.
• A second owner for FFT AVG. Checked after seeing #5980's "#5754's stored FFT AVG" line: ClientDisplaySettings::saveFftAverage/fftAverage have exactly one call site each and the HL2 keeps nothing of its own, so the flip adds an owner where there was none rather than a competing one. #5782 ruled on where the averaging happens, not on persistence; false for HL2 was the shipped default from the RTL work that introduced the field (a325fb99e), not a ruling. I do not read the flip as a preference change needing its own issue — it matches panFrameRateShaping, which the HL2 already owns for the same reason.
• Tests attacked rather than counted. The new test drives real Hl2Backend objects through an injected link edge, and the mutation table's rows map to assertions I can find in the file — it is not asserting the implementation back to itself. Everything above is reasoned from the source in the head checkout; I have no build and ran nothing.

6. Recommendation

Needs maintainer decision, on two separable questions, plus one blocker to fix either way.

The blocker (§3) is independent of the ruling and should be fixed before merge — it silently destroys exactly the state this PR exists to keep, on the path the code itself writes a log line for. The TUNE power, FFT AVG, notch and auto-gain-law work is, in my reading, clean, well-tested, correctly capability-shaped, and solid Principle III; I would take it on its own.

The Receivers domain still has no answer to the question #5777 has been asking since 09-30. The body's claim that it can come out alone holds — m_restoredReceivers, m_restoredTxReceiver, seedFirstReceiverFromMemory(), the addReceiver(seed) refactor, the transmit flag and the receiver-A flat-field override are all on that side of the line, with Notches independent — so if the ruling is no, the surgery is real but bounded. Concrete next step: fix the truncated-replay erasure and the unkey nit, and ping #5777 for the ruling; the rest of the PR does not have to wait on it.

Thanks for the unusually legible write-up — the mutation table and the two hardware runs made this far faster to review than a PR this size normally is, and the honest "not verified" list pointed me straight at the one place the design actually leaks.

---

_{🤖 aethersdr-agent · cost: $15.9290 · model: claude-opus-5}

[jcmerg]

Thanks for the careful pass. The blocker was real.

Addressed in 646e2564:

• Blocker, truncated replay erases the tail: taken as you shaped it. At the break, replayRestoredSession() keeps m_restoredReceivers[i..] in m_replayUnreopened; currentOperatingState() appends them after the live receivers; createPanadapter() and a successful removePanadapter() drop them, after its refusal checks, so a refused close of the last pan keeps them. The ceiling case now also asserts that the stored list still has all 8 entries, and that it shrinks to the live count once the operator closes B.
• TUNE power at unkey: setTune(false) now calls applyTuneMemoryFor(m_currentBandKey) after setKeying(false). Pinned through a real setTune(false, …) with a TxTestAuthority operation.
• numRx connect: seedFirstReceiverFromMemory() became seedOpenReceiversFromMemory(). Every receiver the connect opened takes its own entry; for B.. that includes frequency, mode and passband, with followModeAgc against its previous mode. Pinned with a 2-receiver bring-up.
• Asymmetric emptiness: receivers is now always written, like notches.
• Untested gate: new aReconnectKeepsReceiverALive drives connectRadio() three times: a first connect seeds, a same-serial reconnect keeps the live blanker, another serial seeds again.

Each new guard was mutated and goes red; the table in the body has the rows. The other nine HL2/RadioStateMemory tests are still green locally.

On #5777: the Receivers part still waits for the ruling there, as you say. The rest does not depend on it.

[jensenpat]

Verdict

Approve. Reviewed 646e2564528a4a524ed24a1bc51ac4e3ef6f7e8f. Issue fit is good: this is the HL2 client-memory gap in #5777, plus the TUNE-power, FFT AVG, notch, and auto-RF-gain law/floor setpoints the body lists. Scope stays inside that. Merging accepts #5777's proposed answer (restore each receiver's state, not a persisted count). The issue is not in closingIssuesReferences, so it will stay open.

RadioModel seam: this does not cross it. The only RadioModel edit is the tunePowerCommandIssued forward. It still calls IRadioBackend::setTunePower only when transmitDriveControl->tunePowerAppliesLive is set, and it still returns before that call when TUNE is on but the carrier is not this client's (isTuning() && !tuneCarrierLive()). There is no new family-string branch, no new vendor include, no Flex wire text, and no key. The HL2 sentence in the comment is motivation; the gate is the capability.

Who the widened unkeyed call reaches:

Family	tunePowerAppliesLive	Unkeyed setTunePower
HL2	true	records the band; drive is applied only while this client's carrier is admitted
Icom	true	IcomCivBackend::setTunePower returns immediately when !m_tuning, so no CI-V write
Flex, ANAN	false	not called
Sim, RTL	record absent	not called

Receivers and Notches are new ClientSettingsDomain bits. RadioStateMemory::gateExtension() withholds them unless declared. Flex, Sim, and Icom still declare an empty domain set. ANAN and RTL do not declare either new bit. The extension contents stay inside Hl2Backend.

setTxSlice() during replay moves ownership and band memory. It does not call setKeying.

Scope

Group	Files	What it does
Seam contract	IRadioBackend.h, src/models/RadioModel.cpp	Unkeyed TUNE power is forwarded only to a live-declaring backend
Domain gate	RadioCapabilities.h, RadioStateMemory.cpp	Receivers / Notches sub-objects, same gate on load and store
HL2 memory	Hl2Backend.cpp, Hl2Backend.h	Per-band TUNE power, chosen auto-gain law/floor, receiver and notch replay
Sweep order	MainWindow_SwrSweep.cpp	Restores TUNE power before the frequency, while still on the swept band
Docs	docs/HERMES.md, docs/architecture/radio-capabilities-map.md	Matches the new declarations
Tests	tests/hl2_session_memory_test.cpp, tests/transmit_seam_drop_notice_test.cpp, tests/tests.cmake	Socket-free; registered

No CHANGELOG.md edit. The prior review's truncated-replay erasure and the unkey TUNE-power gap are fixed in this commit (m_replayUnreopened, applyTuneMemoryFor on unkey).

Verification

Required checks on this SHA are green: build, check-windows, check-macos, Static checks. Those jobs do not execute this new test (the per-PR ctest gate is frozen). Local, Qt 6.12.0, QT_QPA_PLATFORM=offscreen, worktree /tmp/aether-grokreview-6259 at 646e25645:

• transmit_seam_drop_notice_test passed
• hl2_session_memory_test passed

The new test injects MetisClient::linkUp. It does not construct or bind a socket (start() is what binds). Icom's unkeyed no-op is from reading IcomCivBackend::setTunePower, not from an Icom test run.

Non-blocking

• A ceiling-truncated replay keeps the receivers it could not open, but currentOperatingState() stamps transmit only on the live m_txDdc. If transmit was on a receiver past the ceiling, the next capture moves that flag onto receiver A. See the inline.
• An SWR sweep aborted by a band change (preserveBandSwitchOnFinish) now records the original TUNE power onto the destination band, because unkeyed setTunePower reaches HL2. Same-band finish is the path the reorder fixes. The body already discloses the disconnect/preserve case for sweep power.

Non-blocking test follow-up

The transmit-flag-on-an-unreopened-tail case above is not asserted. A useful addition on the existing ceiling case: mark transmit on the last remembered receiver, capture after the short replay, and check the flag is still on that entry. HL2 only. Not a merge prerequisite.