chore: release v0.26.17

Reported from a station running an IC-7850 over USB: with split engaged,
turning VFO B moved VFO A slightly. OpsLog writes nothing to that radio on
its own — but it shares it, and what it was sharing was wrong.

Hamlib's 'f' means the VFO IN USE. RigState follows ADIF, where FreqHz is
where we TRANSMIT, and the two are the same number until split is
engaged — so the adapter handed FreqHz over unchanged and every client
asking for the dial was given VFO B. A client that reads the dial and
writes it back, which is what WSJT-X and its like do, then wrote VFO B's
frequency into VFO A. Hence a shift the size of the split offset, and
hence 'it did not do this before': it only happens with split on.

get_split_freq ('i') already answers the transmit frequency and is
untouched. The one-line rule is lifted into shareRXFreq with a test that
includes this case, the simplex case, and a backend that reports split
without ever filling in the receive frequency — which would otherwise
answer a client with 0 Hz.

README.md

@@ -1,322 +1,77 @@
-# OpsLog
+# Transceiver Control Interface
 
-<a href="https://discord.gg/FYM8yw5pT" target="_blank">
+## Introduction
-  <img src="https://img.shields.io/badge/Discord-Join%20the%20server-5865F2?logo=discord&logoColor=white" alt="Join our Discord" />
-</a>
 
-A modern, fast ham-radio logger for Windows — single-strip entry, real-time CAT
+TCI (Transceiver Control Interface) is a network interface for control, data transfer and
-for **OmniRig**, native **FlexRadio/SmartSDR**, native **Icom CI-V** (USB **and**
+synchronization between transceiver/receiver, contest loggers, digital mode software, skimmers
-remote-over-internet, replacing RS-BA1) and **TCI** (SunSDR / Expert Electronics),
+and other software, as well as external power amplifiers, bandpass filter units, antenna switches,
-DX cluster with spot alerts, awards tracking, maps, contest logging, QSL
+radio controllers and other devices.
-management and a QSL-card designer. Built with **Wails v2** (Go backend +
-React/TypeScript frontend), **pure Go** (no CGO): SQLite for configuration,
-optional **shared MySQL** for the logbook so several operators can run one log.
-Fully themeable and bilingual (English / French).
 
-Developed by **F4BPO**.
+TCI was created as a modern alternative to the outdated COM port and audio cable
+interfaces, it uses a full duplex web socket protocol that runs on top of a TCP connection and
+serves for server-client communications, providing cross-platform connectivity. Transceiver works
+as a server, all other software and devices as clients. The server and clients can be inside the
+same computer (program-server, hardware log, etc.-clients) and/or in separate physical devices
+connected through the local network (classical transceiver, power amplifier, antenna switch, FFT
+unit, etc.).
 
----
+The TCI interface contains basic transceiver control commands (analog of CAT system),
+receives CW macros from clients and broadcasts them, outputs transceiver IQ stream to clients,
+receives spots from skimmers and Internet clusters, receives/outputs audio signal to work in
+digital modes.
 
-## Building / developing
+The TCI uses an extensible architecture and can be supplemented with new functions and
+commands, while keeping the old ones operational. Thus, the TCI interface can be extended and
+supplemented to meet the specific needs of any software manufacturer and/or device
+manufacturer (receivers, transceivers, power amplifiers, switches, etc.). The presence of a device
+identifier allows the manufacturers of transceivers and receivers to switch to the TCI interface
+while maintaining the device model designation. The extensibility of the TCI interface allows you
+to create an individual set of commands and functions for each device model, while maintaining
+the basic command set inherent to all transceivers.
 
-- **Dev:** `wails dev` (Vite hot-reload; Go methods reachable at http://localhost:34115).
+Our company advocates universal unification of data exchange between devices and
-- **Build:** `wails build` (use the project's wails v2.11 — `~/go/bin/wails.exe`).
+software by creating the TCI interface for this purpose. Modern transceivers and software must
-- **Regenerate Go↔TS bindings** after changing exported `App` methods:
+communicate using one protocol - the TCI protocol.
-  `wails generate module`.
-- **Release:** `.vscode/release.ps1` (Ctrl+Shift+P → *Tasks: Run Task* →
-  *Release OpsLog*) — bumps the version, pushes source to Gitea, builds the exe
-  and publishes it to Gitea + GitHub releases.
 
----
+## Interface description
 
-## Logging
+Any command represents an ASCII string that contains a command name and a list of
+arguments corresponding to this command. There are reserved characters that cannot be
+included in the command name and command arguments.
 
-- **Single-strip entry:** callsign, RST tx/rx, name/QTH/grid, band/mode,
+List of reserved characters: «:», «,», «;».
-  TX/RX frequency (split), start/end time, comment/note. The contacted entity's
-  **flag** is shown large next to the RST fields.
-- **Callsign lookup** (QRZ.com / HamQTH) with photo, auto-fill of name/QTH/grid
-  and the QRZ.com tab.
-- **Offline DXCC** resolution from `cty.dat` (country, CQ/ITU zones, continent),
-  with `/MM` `/AM` `/B` (beacon) and call-area (`/8`, `/W6`) handling, plus
-  ClubLog DXpedition date overrides.
-- **Recent QSOs**, **Worked-before** matrix (per band/mode slot), bulk re-resolve
-  from cty/QRZ/ClubLog, bulk send to QSL services. A live **selection count**, a
-  **Select all / Unselect all** toggle, and a row limit that keeps the full log
-  fast **but is lifted while a filter is active** (every match is shown, not just
-  the first page).
-- **Advanced QSO filter builder** (field / operator / value, AND / OR, saved
-  presets) with filtered- and selected-row **ADIF export**.
-- **Find duplicates** (Tools) — groups QSOs by same call + band + mode (optionally
-  same day / minute) and lets you pick which to delete.
-- **ADIF 3.1.7 compliant** import/export: a full field dictionary, 30 promoted
-  columns, a generic "extra fields" editor and standard/all export modes.
-- **Profiles:** every setting is per-profile; each profile can point its logbook
-  at the local SQLite file or a **shared MySQL** database (multi-operator).
 
-## Maps & antenna
+Command structure:
+1. Name of the command;
+2. Separating character between command name and arguments «:»;
+3. Separating character between arguments «,»;
+4. End of the command character «;».
 
-- **Main view = two configurable panes** (per profile, Settings → General →
+If a command has no arguments, an end of command symbol is placed after the command
-  *Main view*): great-circle map, locator (street) map, the cluster grid, the
+name. If the command is invalid, it is ignored. The case of letters does not matter.
-  worked-before grid, recent QSOs, the **FlexRadio controls**, the **Icom
-  console** or the **Net control** panel.
-- **Great-circle map** with short/long-path distance & azimuth, selectable
-  basemaps (Light / Voyager / Street / Satellite, all key-free and labelled) and
-  the **antenna beam lobe(s)** drawn from the rotor azimuth.
-- **Rotor compass** (azimuthal-equidistant, click-to-turn) driven by
-  **PstRotator** (UDP), a **4O3A Rotator Genius** (native TCP) or a **microHAM
-  ARCO** controlled natively — no PstRotator needed — over the **LAN** or **USB**
-  using its Yaesu GS-232A protocol.
-- **Ultrabeam** support (Normal / 180° reverse / Bidirectional): the radiating
-  direction is shown in green and the **mechanical boom** in grey, on both the
-  compass and the map, so you never lose track of where the antenna points.
 
-## DX Cluster
+The ExpertSDR3 program acts as a server, which can have several client connections at
+the same time, they will be synchronized with each other by the server. When connecting to the
+ExpertSDR3, the client receives the current status of the ExpertSDR3, first sending initialization
+commands, then parameters to set the status, such as frequency, modulation, etc.
 
-- Multiple cluster servers with auto-reconnect, a master for commands.
+When a parameter change occurs in the ExpertSDR3 (server) program, the server notifies
-- **Filter sidebar** (callsign search, hide-worked, group duplicates, band /
+all connected clients, i.e., clients do not need to poll the server constantly, any change of state
-  mode / status / source) shared by the Cluster tab and the Main-view cluster
+will be sent in time to all clients. If the client sends a new state, the server will set it to itself, as
-  pane, with a show/hide toggle.
+well as send it to all clients, that is, the server acts as a synchronizer. All clients connected to the
-- Per-spot **status** (new / new-band / new-slot / worked), click-to-tune the
+server will be automatically synchronized. This way of work allows to minimize network load,
-  rig, and a multi-band **Band Map** (panadapter-style strips). Optionally, all
+reducing traffic.
-  **digital modes count as one** (DXCC-style) for the new/new-slot colouring and
-  the worked-before matrix badges (Settings → General).
-- **POTA** spots are tagged with their park reference (via `api.pota.app`).
-- **Spot alerts:** rules on call / country / band / mode /
-  spotter, with sound, visual and e-mail notification (Tools → *Alert
-  management*).
 
-## CAT control
+The TCI protocol implements the transmission of receiver IQ stream to clients, which is
+necessary for the work of special skimmer software, they automatically find the station and
+decode it throughout the band, and it also allows you to record radio signals in the file.
 
-Four native backends (Settings → CAT), each with auto-reconnect and a fast,
+TCI is also used to transmit audio signals of the receiver to clients and to receive audio
-non-blocking connect so a powered-off radio never freezes the app:
+signals from clients, i.e., the client can transmit audio signals to ExpertSDR3 for radio
+transmission. The audio stream exchange is designed to work with digital modes, where encoding
+and decoding is performed by third-party software, as well as in voice modes, where audio macros
+can be broadcasted, which is very much in demand in contest loggers.
 
-- **OmniRig** (Rig 1/2, hot-swap) — works with any OmniRig-supported rig.
+When working in contests, it is important to record all on the air operation, for this purpose
-- **FlexRadio (SmartSDR)** over the radio's TCP API — real-time slice freq /
+the audio stream from the line-output is sent to all clients. The resulting audio stream can be
-  mode / split, UDP discovery, and **panadapter spots** (cluster spots pushed to
+recorded to a file or played back with a PC sound card.
-  the Flex display; a click fills the call and **tunes the rig to the right
-  frequency AND mode**).
-- **Icom CI-V** — native, over the radio's **USB** port *or* over the internet
-  via the radio's **built-in LAN server** (see *Remote Icom* below). No RS-BA1 or
-  Remote Utility needed.
-- **TCI** (WebSocket) — SunSDR / ExpertSDR2 and any TCI-compatible server:
-  freq / mode / PTT / split, plus optional panorama spots.
-
-Mode is taken from the radio; the digital sub-mode (FT4 vs FT8) is inferred from
-the frequency. **Per-band Flex RX/TX antennas** can be configured and are applied
-automatically on band change.
-
-### FlexRadio control tab (SmartSDR-style)
-
-Shown only when the CAT backend is a FlexRadio:
-
-- **Transmit:** RF power, tune power, TUNE, MOX, speech processor (NOR/DX/DX+),
-  VOX (+ level + delay), monitor (+ level), mic gain.
-- **Receive (active slice):** RX/TX **antenna** selectors and a **DAX** toggle
-  (TX audio through DAX, for WSJT-X & co), AGC mode/threshold, audio level,
-  NB / WNB / NR / ANF, and — on **SmartSDR v4** radios (8000 / Aurora series) —
-  the extra DSP tools **NRL, NRS, NRF** (with level) plus **RNN** (AI noise
-  reduction) and **ANFT** (FFT auto-notch), shown automatically when the radio
-  supports them. **RIT / XIT** with wheel / ± tuning.
-- **Antenna tuner (ATU):** tune / bypass / memories.
-- **Amplifier:** the amp card follows whichever amplifier is configured, with a
-  dropdown to pick it when **several amplifiers** are set up (e.g. two SPEs run
-  in parallel). See *Amplifiers & switches* below.
-- **Live meters** over the UDP VITA-49 stream: S-meter (S-units), forward power
-  (W), SWR, ALC, PA temperature, voltage, plus the amplifier's meters.
-
-### Icom control tab
-
-Shown when the CAT backend is Icom (USB or network). A full RS-BA1-style console:
-
-- **Twin VFO readout** (MAIN / SUB) with the big tabular frequency, mode badge,
-  band and RIT/ΔTX offset, and a **mode-button row** (SSB / CW / RTTY / PSK /
-  AM / FM).
-- **Spectrum scope + waterfall** (panadapter): ON/OFF, CTR/FIX, double-click to
-  tune, and **◀ ⊙ ▶** buttons to centre the scope on the current frequency
-  (±50 kHz) and pan left/right.
-- **Live meters** always visible: S-meter (click → fill RST), power in watts, SWR.
-- **Receive DSP:** AF / RF gain, squelch, AGC, preamp, attenuator, filter
-  (FIL1/2/3), NB, NR, ANF and — **on CW only** — the **APF** (audio peak filter).
-- **Passband / notch:** Twin PBT (inner / outer), manual notch + position.
-- **Transmit:** RF power, MOX, TUNE, **split with an automatic offset**
-  (+5 kHz on SSB, +1 kHz on CW), and monitor. On **voice modes only**: mic gain,
-  speech compressor, VOX (+ gain + anti-VOX). Controls that don't apply to the
-  current mode are hidden automatically.
-- **Bands & antenna:** one-touch band buttons and ANT1/ANT2 selection.
-- **Clarifiers:** RIT and ΔTX with wheel / ± tuning (Ctrl+←/→ nudges RIT).
-- **Power ON / OFF** buttons (manual by design — the app never wakes the rig on
-  connect).
-- **CW keying** can run through the radio's own keyer (see *Keyers* below).
-
-### Remote Icom (over the internet, no RS-BA1)
-
-OpsLog speaks the IC-7610's built-in network protocol directly — it **replaces
-both the Icom Remote Utility and RS-BA1**. Enter the radio's IP, the Network
-User1 name/password and the CI-V address, and the whole Icom console works over
-the LAN/internet: login + token (auto-renewed), CI-V tunnel, receive-side
-retransmit for a rock-solid link even with the panadapter streaming, and manual
-power ON/OFF. (Audio is out of scope — use the radio in USB + a voice link such
-as Mumble.)
-
-## Keyers & audio
-
-- **CW keyer** with macros and F-key macros. The keyer engine is selectable:
-  **WinKeyer** (K1EL WK1/2/3 over a COM port), **FlexRadio CWX** (the radio's
-  built-in keyer over the SmartSDR API — type-ahead and backspace, no WinKeyer or
-  SmartCAT needed), **Icom** (the radio's own keyer over CI-V — no extra hardware,
-  works over the remote link too) or **TCI**.
-- **Digital Voice Keyer** (DVK): record F1–F6 voice messages and transmit them.
-- **QSO audio recording:** continuous rolling capture; on *Log QSO* the contact
-  is saved to a per-QSO WAV (`CALL_YYYYMMDD_HHMMSS.wav`); mixes RX + mic.
-
-## Amplifiers & switches
-
-- **Amplifiers** — configure **one or several** amps (Settings → Amplifier is a
-  list; e.g. two SPEs run in parallel for more power). Each amp's control card
-  appears on the FlexRadio tab and in **Station Control**, with a dropdown to
-  choose which one it shows; the bottom status bar carries **one clickable chip
-  per amp** (green = OPERATE, orange = STANDBY, red = offline). Supported:
-  - **PowerGenius XL** (4O3A) over direct TCP — operate/standby, fan-mode
-    selector and fault display.
-  - **SPE Expert** (1.3K-FA / 1.5K-FA / 2K-FA) over **USB** (virtual COM) or the
-    **network** (RS232-to-Ethernet bridge) — operate/standby, ON/OFF,
-    Low / Mid / High output level, an output-power bar and live status (band,
-    SWR, PA current, temperature, warnings/alarms).
-  - **ACOM** (500S / 600S / 700S / 1200S / 2020S) over **USB** or the **network**
-    (RS232-to-Ethernet bridge) — operate/standby/off and live telemetry (forward
-    & reflected power, SWR, PA temperature, band, fan, faults). Power-ON works
-    over a serial cable that wires the DTR/RTS lines.
-- **Antenna Genius** (4O3A) antenna switch over TCP/GSCP — a docked A/B
-  antenna-switch widget.
-- **Station Control** panel (dockable, drag-to-reorder widgets): the **rotator**,
-  **Ultrabeam** element control and **relay boards** — WebSwitch 1216H, KMTronic,
-  **Denkovi** USB (FT245 D2XX bit-bang, 4 or 8 relays) and generic USB-serial
-  (CH340 / LCUS, A0 protocol) — for station power, antennas and accessories.
-- **Relay auto-control** (Settings): switch Station-Control relays automatically
-  from the rig frequency / band (like PstRotator) — per relay, a frequency window
-  or a set of bands.
-
-## QSL & awards
-
-- **Awards engine:** built-in + custom award definitions (shared **globally**
-  across profiles) — DXCC, WAS / WAZ / WAC, WPX, IOTA / POTA / SOTA / WWFF,
-  **DDFM**, worked/confirmed/validated by band & mode, OR rules and manual
-  reference assignment, live reference detection on call entry, **reference-list
-  import** for totals/names, and a **Rescan** that re-pulls the logbook (picks up
-  fresh LoTW/QRZ confirmations).
-- **QSL services:** ClubLog (batched ADIF upload), LoTW, QRZ.com, eQSL — upload
-  and **confirmation download** (which auto-refreshes the award stats).
-- **QSL Card Designer** (see below).
-- **E-mail eQSL:** right-click a QSO → *Send eQSL by e-mail* via the configured
-  SMTP account. (Outlook/Hotmail disable basic-auth SMTP — use Gmail with an app
-  password, or a Microsoft app password.)
-
-## Contest logging
-
-- **Contest tab:** pick a contest (built-in ADIF `CONTEST_ID` list) and an
-  exchange (running serial or a fixed exchange). OpsLog auto-fills `CONTEST_ID`
-  and the sent/received serials (`STX` / `SRX`), enforces a window start/end,
-  flags dupes and keeps a live scoreboard.
-
-## Statistics
-
-- **Logbook statistics dashboard:** headline tiles (QSOs, unique callsigns, DXCC
-  entities, continents, % confirmed) plus charts — QSOs **by mode**, a per-band
-  **CW / phone / data** split, **activity over time** (rolling day / 7-day /
-  30-day / 12-month views), by operator and by continent. Date-range, per-operator
-  and per-contest filters, and a **Table** view that mirrors every chart.
-
-## Multi-operator live status (special events)
-
-For a multi-op special-event call on a shared MySQL logbook (e.g. **TM74TFR**),
-publishing is **automatic** — no setting to turn on. Each OpsLog instance
-heartbeats its current activity (operator call, band, frequency, mode) into a
-`live_status` table every ~15 s, and drops back to *off air* automatically 5 min
-after the last logged QSO. A small PHP renderer
-([`docs/livestatus/tm74-status.php`](docs/livestatus/tm74-status.php)) on your
-own web server reads that table and produces a live page/image you can embed on
-the station's **QRZ.com** bio (`<img src="…/tm74-status.php?img=1">`). OpsLog
-only writes to the DB — it is not a web server.
-
-## Net control
-
-- **Directed-net logging** (Tools → Net): a global roster (`nets.json`) plus an
-  in-memory active session — check stations in, then log them individually or the
-  whole net at once (**Log everyone**) using the CAT frequency. **Drag & drop**
-  between the two lists (roster → on-air starts a QSO, on-air → roster logs it),
-  and after each log the next on-air station is selected automatically so you can
-  chain contacts.
-
-## Appearance & language
-
-- **Themes:** four complete themes (Warm light, Warm dark, Graphite dark, High
-  contrast) plus **Auto** (follows the OS light/dark preference), selectable in
-  Settings → General. Every panel and every AG-Grid table follows the theme.
-- **Bilingual:** full **English / French** UI, with a first-run flag chooser and
-  a switcher in Settings → General.
-
-## Security
-
-- **Secret vault:** opt-in passphrase encryption of the stored passwords
-  (AES-GCM + PBKDF2). Encrypted values are portable; a single unlock prompt at
-  launch decrypts them for the session.
-
-## Integrations (outbound)
-
-- **UDP emitters:** push the current frequency to **PstRotator**, radio info in
-  **N1MM `RadioInfo`** format, or an **ADIF record on each logged QSO** — so
-  external tools (rotator control, digital apps, other loggers) stay in sync.
-
-## Other
-
-- **Autostart:** launch external programs (WSJT-X, JTAlert, rotator control…) at
-  OpsLog startup, skipping any already running.
-- **Backup:** optional database + ADIF backup at shutdown.
-- **Update check** at startup and every 5 minutes (and on opening Help → About),
-  with a toast (toggleable), plus a **What's new** dialog that shows the changelog
-  (English / French) on the first launch after an update — reopenable any time
-  from the Help menu.
-- **Anonymous usage telemetry** (a once-a-day heartbeat: random install ID +
-  version + OS — no callsign or QSO data; opt-out in Preferences).
-
----
-
-## QSL Card Designer
-
-Tools → *QSL Card Designer…* turns a few photos into a polished eQSL card:
-
-1. Pick 1–6 photos (jpeg/png). OpsLog analyzes them offline (detail/luminance
-   grid) and proposes **3 designs** — callsign in the calmest zone of the best
-   photo, operator name, CQ/ITU zones + locator line, country flag, the other
-   photos as bordered inserts, and a per-QSO confirmation box.
-2. Pick a proposal and fine-tune it: click an element to select, drag to move,
-   change font / style preset (gel gold, gel silver, classic white outline,
-   script, flat) and per-preset knobs in the right panel.
-3. Save the template (photos are copied into `data/qsl/templates/<id>/`, so the
-   originals can move). One template can be the default per profile.
-
-Sending: right-click a QSO → *Send eQSL by e-mail*. The card is rendered with
-that QSO's data, rasterized to a ≤ 800 KB JPEG, archived in `data/qsl/outbox/`
-and sent through the configured SMTP account to the address found by the
-QRZ/HamQTH lookup. On success the QSO is stamped `EQSL_SENT=Y` (ADIF). The
-e-mail subject/body templates live in the designer
-(`{CALL} {DATE} {BAND} {MODE} {MYCALL}` variables).
-
-Fonts: Archivo Black, Lilita One, Baloo 2, Oswald, Great Vibes, Allura (all
-OFL, embedded — licenses in `internal/qslcard/assets/fonts/`); Cooper Black is
-offered when MS Office installed it. Flags: flag-icons (MIT), embedded for the
-commonly-worked DXCC entities.
-
----
-
-## Data & storage
-
-- **Config** (settings, profiles, rigs/antennas, cluster nodes, lookup cache,
-  award lists, QSL templates) always lives in the local SQLite file under
-  `data/` — instant even when the logbook is on a far-away MySQL.
-- **Logbook** (QSOs) lives where the active profile points it: the local SQLite
-  file or a per-profile shared **MySQL** database.
-
----
-
-*A French version of this document is available in [README.fr.md](README.fr.md).*

antgenius_myant.go

@@ -0,0 +1,129 @@
+package main
+
+// MY_ANTENNA from the Antenna Genius.
+//
+// A station with a switch has a truth the log does not: which antenna is
+// actually connected right now. The working conditions hold what was PLANNED
+// for the band — the default antenna ticked for 20 m — and that is right until
+// the operator throws the switch, at which point the log quietly keeps claiming
+// the other antenna for the rest of the session.
+//
+// So, as an option: when the Antenna Genius knows which antenna is selected,
+// its name wins. The name is the one configured on the device, because that is
+// the name the operator gave it and the one they will look for in the log.
+//
+// WHICH PORT is the whole difficulty. An Antenna Genius has two, A and B, and a
+// FlexRadio has two transmit antenna jacks, ANT1 and ANT2. The QSO was made on
+// exactly one of them, and stamping the wrong port's antenna would be worse
+// than stamping the band default — a wrong answer that looks authoritative. The
+// radio's own TX antenna selection is what decides.
+
+import (
+	"strings"
+
+	"hamlog/internal/antgenius"
+	"hamlog/internal/applog"
+)
+
+const (
+	keyAntGeniusMyAnt     = "antgenius.my_antenna"    // use the selected antenna as MY_ANTENNA
+	keyAntGeniusPortForA1 = "antgenius.port_for_ant1" // which AG port ANT1 is wired to (1=A, 2=B)
+)
+
+// antGeniusPortFor maps the radio's transmit antenna jack to an Antenna Genius
+// port.
+//
+// The wiring is the station's, not something that can be read from either
+// device: ANT1 usually goes to port A and ANT2 to port B, which is what the
+// setting defaults to, but a station wired the other way round would otherwise
+// log every QSO with the other antenna's name.
+func (a *App) antGeniusPortFor(txAnt string) int {
+	ant1Port := 1
+	if a.settingOr(keyAntGeniusPortForA1, "1") == "2" {
+		ant1Port = 2
+	}
+	other := 3 - ant1Port
+	switch strings.ToUpper(strings.TrimSpace(txAnt)) {
+	case "ANT1", "ANT 1", "1", "A":
+		return ant1Port
+	case "ANT2", "ANT 2", "2", "B":
+		return other
+	}
+	return 0 // XVTR, a rig with one jack, or nothing reported: no port to name
+}
+
+// antGeniusAntennaName returns the name of the antenna currently selected on
+// the port the radio is transmitting through, or "" when it cannot be told.
+//
+// Deliberately silent rather than approximate. Every "" here means the log
+// keeps the band default it would have had anyway, which is a defensible
+// answer; a guessed port is not.
+func (a *App) antGeniusAntennaName() string {
+	if a.antgenius == nil {
+		return ""
+	}
+	st := a.antgenius.GetStatus()
+	if !st.Connected {
+		return ""
+	}
+	// The jack in use comes from the FlexRadio's own state — TXAnt lives on the
+	// Flex panel state, not on the backend-agnostic RigState, because only a
+	// Flex has named antenna jacks to report.
+	txAnt := ""
+	if a.cat != nil {
+		if fs, ok := a.cat.FlexState(); ok {
+			txAnt = fs.TXAnt
+		}
+	}
+	port := a.antGeniusPortFor(txAnt)
+	if port == 0 {
+		// One switch port in use and no ambiguity about which: a station whose
+		// radio has a single jack still deserves the name. Two ports carrying
+		// different antennas with nothing to choose between them does not.
+		if st.PortA > 0 && st.PortB == 0 {
+			port = 1
+		} else if st.PortB > 0 && st.PortA == 0 {
+			port = 2
+		} else {
+			return ""
+		}
+	}
+	idx := st.PortA
+	if port == 2 {
+		idx = st.PortB
+	}
+	if idx <= 0 {
+		return ""
+	}
+	return antGeniusNameOf(st, idx)
+}
+
+// antGeniusNameOf looks an antenna index up in the device's own list.
+func antGeniusNameOf(st antgenius.Status, idx int) string {
+	for _, ant := range st.Antennas {
+		if ant.Index == idx {
+			return strings.TrimSpace(ant.Name)
+		}
+	}
+	return ""
+}
+
+// applyAntGeniusAntenna overrides MY_ANTENNA with the switch's selection, when
+// the option is on.
+//
+// Called at log time rather than while the entry form is open: an operator who
+// changes antenna mid-QSO is telling us what the contact was actually made on,
+// and the value that matters is the one at the moment it is logged.
+func (a *App) applyAntGeniusAntenna(myAntenna *string) {
+	if myAntenna == nil || a.settingOr(keyAntGeniusMyAnt, "") != "1" {
+		return
+	}
+	name := a.antGeniusAntennaName()
+	if name == "" {
+		return
+	}
+	if *myAntenna != name {
+		applog.Printf("antgenius: MY_ANTENNA %q → %q (the antenna selected on the switch)", *myAntenna, name)
+	}
+	*myAntenna = name
+}

antgenius_myant_test.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/antgenius"
+)
+
+// The switch has two ports and the radio two antenna jacks; a QSO was made
+// through exactly one of them. Naming the wrong port's antenna would be worse
+// than naming the band default — it is a wrong answer that looks authoritative.
+func TestAntennaNameComesFromTheDeviceList(t *testing.T) {
+	st := antgenius.Status{
+		Connected: true,
+		PortA:     2,
+		PortB:     5,
+		Antennas: []antgenius.Antenna{
+			{Index: 2, Name: "OB11-5 20/15/10"},
+			{Index: 5, Name: "Vertical 80m"},
+		},
+	}
+	if got := antGeniusNameOf(st, 2); got != "OB11-5 20/15/10" {
+		t.Fatalf("port A antenna = %q", got)
+	}
+	if got := antGeniusNameOf(st, 5); got != "Vertical 80m" {
+		t.Fatalf("port B antenna = %q", got)
+	}
+	// An index the device never described has no name to give, and inventing
+	// one ("Antenna 7") would put a label in the log that exists nowhere else.
+	if got := antGeniusNameOf(st, 7); got != "" {
+		t.Fatalf("unknown index produced %q", got)
+	}
+}
+
+// The jack-to-port wiring is the station's own. Defaulting ANT1 to port A is a
+// convention, not a fact, so it is a setting — and the mapping has to hold both
+// ways round.
+func TestJackToPortMapping(t *testing.T) {
+	app := &App{}
+	// No settings store: settingOr falls back, which is ANT1 → port A.
+	if got := app.antGeniusPortFor("ANT1"); got != 1 {
+		t.Fatalf("ANT1 mapped to port %d, want A(1)", got)
+	}
+	if got := app.antGeniusPortFor("ANT2"); got != 2 {
+		t.Fatalf("ANT2 mapped to port %d, want B(2)", got)
+	}
+	// A jack that is neither — a transverter port, or a rig that reports
+	// nothing — has no port to name, and saying so beats guessing.
+	if got := app.antGeniusPortFor("XVTR"); got != 0 {
+		t.Fatalf("XVTR mapped to port %d, want none", got)
+	}
+	if got := app.antGeniusPortFor(""); got != 0 {
+		t.Fatalf("an unreported jack mapped to port %d, want none", got)
+	}
+}

app.go

@@ -106,6 +106,7 @@ const (
 	keyListsRSTPhone   = "lists.rst_phone"
 	keyListsRSTCW      = "lists.rst_cw"
 	keyListsRSTDigital = "lists.rst_digital"
+	keyListsSatellites = "lists.satellites" // the satellites this station works (SAT_NAME dropdown)
 
 	keyCATEnabled    = "cat.enabled"
 	keyCATBackend    = "cat.backend"     // "omnirig" | "flex"
@@ -132,8 +133,15 @@ const (
 	keyCATYaesuPort       = "cat.yaesu.port"      // Yaesu CAT serial port (e.g. COM4)
 	keyCATYaesuBaud       = "cat.yaesu.baud"      // Yaesu CAT baud (FTDX10/101 default 38400)
 	keyCATKenwoodHost     = "cat.kenwood.host"    // Kenwood CAT over a network serial bridge (ser2net), "host:port"
-	keyCATKenwoodPort     = "cat.kenwood.port"    // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	// keyCATKenwoodLink says HOW the radio is reached: "usb" (a COM port),
-	keyCATKenwoodBaud     = "cat.kenwood.baud"    // Kenwood CAT baud (TS-590 default 9600, TS-890 115200)
+	// "bridge" (the same CAT bytes over TCP — ser2net, an Ethernet-serial
+	// adapter), or "native" (the radio's own network protocol). Kept apart from
+	// the address because the three are different transports, and inferring the
+	// choice from whether a field happened to be filled in is how an operator
+	// ends up with a host typed in and a radio that never answers.
+	keyCATKenwoodLink = "cat.kenwood.link"
+	keyCATKenwoodPort = "cat.kenwood.port" // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	keyCATKenwoodBaud = "cat.kenwood.baud" // Kenwood CAT baud (TS-590 default 9600, TS-890 115200)
 	// One key PER BACKEND, deliberately not shared. A Xiegu fix that reached
 	// into the Yaesu and Kenwood backends is what broke them in 0.22.7/0.22.8;
 	// the rule since is that nothing a backend does may be steered by another
@@ -457,6 +465,9 @@ type CATSettings struct {
 	KenwoodHost     string `json:"kenwood_host"`      // "host:port" of a serial-over-network bridge (ser2net, Ethernet-serial
 	// adapter). NOT the radio’s own RJ45, which speaks Kenwood’s KNS/ARCP.
 	KenwoodPort string `json:"kenwood_port"` // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	// KenwoodLink: "usb" | "bridge" | "native". Empty means usb, unless a host
+	// was already configured by an older build — see GetCATSettings.
+	KenwoodLink string `json:"kenwood_link"`
 	KenwoodBaud int    `json:"kenwood_baud"` // Kenwood CAT baud (TS-590 default 9600)
 	// What a DATA/digital mode (FT8, PSK…) sets on the rig: "usb" (default), "data"
 	// (MD6 — Elecraft K3/K4 DATA mode) or "keep" (leave the rig's mode untouched,
@@ -516,6 +527,12 @@ type ListsSettings struct {
 	RSTPhone   []string     `json:"rst_phone"`   // RS reports for phone modes
 	RSTCW      []string     `json:"rst_cw"`      // RST reports for CW/RTTY/PSK
 	RSTDigital []string     `json:"rst_digital"` // dB reports for FT8/FT4/JT…
+	// Satellites the station works, offered as a dropdown on the satellite
+	// fields. A list rather than free text because SAT_NAME is matched
+	// character for character by the awards and by LoTW: "AO-91" and "AO91"
+	// are two different satellites to everything downstream, and typing it
+	// afresh on every pass is how one of them appears in a log.
+	Satellites []string `json:"satellites"`
 }
 
 var defaultBands = []string{
@@ -781,8 +798,8 @@ type App struct {
 	// so closing the QSL Manager — or starting another download — stops the previous
 	// one instead of leaving it running against the app-lifetime context (which made
 	// a still-running QRZ sync bleed its log into a freshly started LoTW download).
-	confDLMu       sync.Mutex
+	confDLMu     sync.Mutex
-	confDLCancel   context.CancelFunc
+	confDLCancel context.CancelFunc
 
 	// hamlogUnmatched holds the confirmations the last HAMLOG.online import
 	// could not place onto a QSO, kept so they can be exported and worked
@@ -790,31 +807,31 @@ type App struct {
 	// accumulated: it describes one run, not a history.
 	hamlogUnmatchedMu sync.Mutex
 	hamlogUnmatched   []qso.QSO
-	udpLogMu       sync.Mutex             // serialises UDP auto-log so concurrent packets can't both pass the dedup check
+	udpLogMu          sync.Mutex             // serialises UDP auto-log so concurrent packets can't both pass the dedup check
-	adifMonMu      sync.Mutex             // guards the ADIF-monitor config (file list + per-file read offsets)
+	adifMonMu         sync.Mutex             // guards the ADIF-monitor config (file list + per-file read offsets)
-	syncMu         sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
+	syncMu            sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
-	syncSent       int64                  // changes written to the folder this session
+	syncSent          int64                  // changes written to the folder this session
-	syncReceived   int64                  // changes taken from the other machines this session
+	syncReceived      int64                  // changes taken from the other machines this session
-	syncLast       time.Time              // last completed pass, for the status panel
+	syncLast          time.Time              // last completed pass, for the status panel
-	syncErr        string                 // last folder error, shown in settings — a share that dropped is otherwise invisible
+	syncErr           string                 // last folder error, shown in settings — a share that dropped is otherwise invisible
-	relayAutoMu    sync.Mutex             // serialises relay auto-control evaluation
+	relayAutoMu       sync.Mutex             // serialises relay auto-control evaluation
-	relayAutoLast  map[string]bool        // deviceID|relay → last applied on/off, so we only switch on a real change
+	relayAutoLast     map[string]bool        // deviceID|relay → last applied on/off, so we only switch on a real change
-	relayAutoOn    atomic.Bool            // cached "auto-control enabled" so the CAT hot path skips work when off
+	relayAutoOn       atomic.Bool            // cached "auto-control enabled" so the CAT hot path skips work when off
-	relayDrvMu     sync.Mutex             // guards the cached relay drivers below
+	relayDrvMu        sync.Mutex             // guards the cached relay drivers below
-	relayDrv       map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
+	relayDrv          map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
-	pttPort        serial.Port            // open serial port while PTT (RTS/DTR) is asserted
+	pttPort           serial.Port            // open serial port while PTT (RTS/DTR) is asserted
-	pttKeyedMethod string                 // "cat" | "rts" | "dtr" while keyed; "" when idle
+	pttKeyedMethod    string                 // "cat" | "rts" | "dtr" while keyed; "" when idle
-	pttGen         int64                  // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
+	pttGen            int64                  // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
-	startupErr     string                 // captured for surfacing to the frontend
+	startupErr        string                 // captured for surfacing to the frontend
-	settingsScoped atomic.Bool            // true once a.settings is scoped to the active profile — GetUIPref/SetUIPref (per-profile) must wait for it, else an early call reads the wrong scope and e.g. resets the theme
+	settingsScoped    atomic.Bool            // true once a.settings is scoped to the active profile — GetUIPref/SetUIPref (per-profile) must wait for it, else an early call reads the wrong scope and e.g. resets the theme
-	dbPath         string                 // settings/config database file (settings + profiles); may be a user-chosen location
+	dbPath            string                 // settings/config database file (settings + profiles); may be a user-chosen location
-	logbookPath    string                 // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
+	logbookPath       string                 // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
-	logDbPath      string                 // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
+	logDbPath         string                 // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
-	logDb          *sql.DB                // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
+	logDb             *sql.DB                // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
-	dbBackend      string                 // "sqlite" | "mysql" — the logbook backend actually opened at startup
+	dbBackend         string                 // "sqlite" | "mysql" — the logbook backend actually opened at startup
-	dbBackendErr   string                 // non-empty when a configured MySQL backend failed and we fell back to SQLite
+	dbBackendErr      string                 // non-empty when a configured MySQL backend failed and we fell back to SQLite
-	offlineQ       *offlineq.Queue        // ADIF outbox: QSOs logged while the DB was unreachable
+	offlineQ          *offlineq.Queue        // ADIF outbox: QSOs logged while the DB was unreachable
-	offlineMode    bool                   // last write failed because the DB was unreachable
+	offlineMode       bool                   // last write failed because the DB was unreachable
 
 	catFlexSpots       bool // push cluster spots to the FlexRadio panadapter
 	catFlexDVKDax      bool // raise the Flex transmit DAX button around a voice message
@@ -977,6 +994,11 @@ func NewApp() *App { return &App{} }
 
 func (a *App) startup(ctx context.Context) {
 	a.ctx = ctx
+	// One line in the startup log too, not only in OpsLog's own: the two
+	// together say whether a launch that produced no window got as far as our
+	// code at all, which is the fork every "it does not start" report turns on.
+	startupReached.Store(true)
+	bootLog("OnStartup reached")
 
 	dataDir, err := userDataDir()
 	if err != nil {
@@ -1537,6 +1559,8 @@ func (a *App) startup(ctx context.Context) {
 // it — it appears already sized and positioned, never jumping into place after
 // launch. Show is unconditional: whatever happens above, the window must appear.
 func (a *App) domReady(ctx context.Context) {
+	bootLog("OnDomReady reached — the window has painted")
+	clearLaunchMarker()
 	a.restoreWindowPosition()
 	wruntime.WindowShow(ctx)
 	// The one number that matches what the operator actually experiences: click
@@ -2101,6 +2125,7 @@ func (a *App) restoreWindowPosition() {
 	if a.ctx == nil {
 		return
 	}
+	logMonitorLayout()
 	ws, ok := readWindowState(a.dataDir)
 	if !ok {
 		applog.Printf("window: no saved geometry — opening where Windows puts it")
@@ -2139,8 +2164,19 @@ func (a *App) restoreWindowPosition() {
 	// forever — with no way back short of deleting window.json, which nobody
 	// knows to do. Fall back to the default placement instead.
 	if !onSomeMonitor(ws.X, ws.Y, ws.Width, ws.Height) {
-		applog.Printf("window: saved position %d,%d (%dx%d) is off every monitor — opening at the default placement",
+		// Moved onto the nearest monitor rather than handed back to Windows.
-			ws.X, ws.Y, ws.Width, ws.Height)
+		// Giving up lost the size as well as the position and dropped the window
+		// on the primary screen wherever Windows felt like; clamping keeps the
+		// window the operator had, somewhere they can see it.
+		nx, ny, moved := clampToVisible(ws.X, ws.Y, ws.Width, ws.Height)
+		if !moved {
+			applog.Printf("window: saved position %d,%d (%dx%d) is off every monitor and no monitor could be read — opening at the default placement",
+				ws.X, ws.Y, ws.Width, ws.Height)
+			return
+		}
+		applog.Printf("window: saved position %d,%d is off every monitor (%s) — moved to %d,%d",
+			ws.X, ws.Y, describeMonitors(monitorRects()), nx, ny)
+		wruntime.WindowSetPosition(a.ctx, nx, ny)
 		return
 	}
 	wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
@@ -2151,13 +2187,7 @@ func (a *App) restoreWindowPosition() {
 // pixel: a window overlapping the screen edge by 2 px is, in practice, as lost
 // as one entirely outside it. When the desktop bounds can't be read, it says yes
 // — better to honour the operator's saved position than to second-guess it.
-func onSomeMonitor(x, y, w, h int) bool {
+func onSomeMonitor(x, y, w, h int) bool { return onSomeMonitorImpl(x, y, w, h) }
-	vx, vy, vw, vh, ok := virtualScreenBounds()
-	if !ok {
-		return true
-	}
-	return overlapsEnough(x, y, w, h, vx, vy, vw, vh)
-}
 
 // overlapsEnough is the geometry behind onSomeMonitor, split out so it can be
 // tested — the virtual desktop origin is NEGATIVE when a monitor sits left of or
@@ -3324,6 +3354,9 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	if q.MyAntenna == "" {
 		q.MyAntenna = p.MyAntenna
 	}
+	// The switch has the last word, when asked to: everything above is what was
+	// PLANNED for this band, and the Antenna Genius knows what is connected.
+	a.applyAntGeniusAntenna(&q.MyAntenna)
 	if q.TXPower == nil && p.TxPower != nil {
 		v := *p.TxPower
 		q.TXPower = &v
@@ -8035,27 +8068,30 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if a.settings == nil {
 		return CATSettings{Backend: "omnirig", OmniRigNum: 1, PollMs: 250}, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATKenwoodLink, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort)
 	if err != nil {
 		return CATSettings{}, err
 	}
 	out := CATSettings{
-		Enabled:          m[keyCATEnabled] == "1",
+		Enabled:         m[keyCATEnabled] == "1",
-		Backend:          m[keyCATBackend],
+		Backend:         m[keyCATBackend],
-		OmniRigNum:       1,
+		OmniRigNum:      1,
-		FlexHost:         m[keyCATFlexHost],
+		FlexHost:        m[keyCATFlexHost],
-		FlexPort:         4992,
+		FlexPort:        4992,
-		FlexSpots:        m[keyCATFlexSpots] == "1",
+		FlexSpots:       m[keyCATFlexSpots] == "1",
-		FlexDVKDax:       m[keyCATFlexDVKDax] == "1",
+		FlexDVKDax:      m[keyCATFlexDVKDax] == "1",
-		FlexDecodeSpots:  m[keyCATFlexDecodeSpots] == "1",
+		FlexDecodeSpots: m[keyCATFlexDecodeSpots] == "1",
-		FlexDecodeSecs:   120,
+		FlexDecodeSecs:  120,
-		XieguPort:        m[keyCATXieguPort],
+		XieguPort:       m[keyCATXieguPort],
-		XieguBaud:        19200,
+		XieguBaud:       19200,
-		XieguAddr:        cat.XieguDefaultAddr,
+		XieguAddr:       cat.XieguDefaultAddr,
-		YaesuPort:        m[keyCATYaesuPort],
+		YaesuPort:       m[keyCATYaesuPort],
-		YaesuBaud:        38400,
+		YaesuBaud:       38400,
-		KenwoodPort:      m[keyCATKenwoodPort],
+		KenwoodPort:     m[keyCATKenwoodPort],
-		KenwoodHost:      m[keyCATKenwoodHost],
+		KenwoodHost:     m[keyCATKenwoodHost],
+		// An install that predates the setting is read from what it has: a host
+		// filled in meant the bridge, since that is what the old code preferred.
+		KenwoodLink:      kenwoodLinkOr(m[keyCATKenwoodLink], m[keyCATKenwoodHost]),
 		KenwoodBaud:      9600,
 		YaesuLowLines:    m[keyCATYaesuLowLines] == "1",
 		KenwoodLowLines:  m[keyCATKenwoodLowLines] == "1",
@@ -8255,6 +8291,7 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATYaesuBaud:        strconv.Itoa(s.YaesuBaud),
 		keyCATKenwoodPort:      strings.TrimSpace(s.KenwoodPort),
 		keyCATKenwoodHost:      strings.TrimSpace(s.KenwoodHost),
+		keyCATKenwoodLink:      kenwoodLinkOr(s.KenwoodLink, s.KenwoodHost),
 		keyCATKenwoodBaud:      strconv.Itoa(s.KenwoodBaud),
 		keyCATYaesuLowLines:    b01(s.YaesuLowLines),
 		keyCATKenwoodLowLines:  b01(s.KenwoodLowLines),
@@ -8313,8 +8350,49 @@ type AudioSettings struct {
 
 // ListAudioInputDevices / ListAudioOutputDevices enumerate WASAPI endpoints
 // for the device dropdowns.
-func (a *App) ListAudioInputDevices() ([]audio.Device, error)  { return audio.ListInputDevices() }
+// ListAudioInputDevices lists the microphones and line inputs, plus THE RADIO
-func (a *App) ListAudioOutputDevices() ([]audio.Device, error) { return audio.ListOutputDevices() }
+// when the CAT link carries its receive audio.
+//
+// Same reasoning as the output list: over TCI there is no sound device for
+// Windows to show, so without this the one correct answer to "where does the
+// received audio come from" could not be chosen at all.
+func (a *App) ListAudioInputDevices() ([]audio.Device, error) {
+	devs, err := audio.ListInputDevices()
+	if err != nil {
+		return devs, err
+	}
+	if a.tciAudioAvailable() {
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+	}
+	return devs, nil
+}
+
+// tciAudioAvailable says whether the active CAT backend is a radio that streams
+// its audio over the CAT link.
+func (a *App) tciAudioAvailable() bool {
+	if a.cat == nil {
+		return false
+	}
+	_, ok := a.cat.TCIAudioState()
+	return ok
+}
+
+// ListAudioOutputDevices lists the sound cards, plus THE RADIO ITSELF when the
+// CAT link can carry transmit audio.
+//
+// Offered only while it is actually available, and named as a radio rather than
+// as a protocol: an operator choosing where their voice goes is picking between
+// "my sound card" and "the radio", not between WASAPI and TCI.
+func (a *App) ListAudioOutputDevices() ([]audio.Device, error) {
+	devs, err := audio.ListOutputDevices()
+	if err != nil {
+		return devs, err
+	}
+	if audio.NetworkPlayerReady() {
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+	}
+	return devs, nil
+}
 
 // GetAudioSettings returns the stored audio config (preroll defaults to 8s).
 func (a *App) GetAudioSettings() (AudioSettings, error) {
@@ -8416,6 +8494,20 @@ func (a *App) SaveAudioSettings(s AudioSettings) error {
 			return err
 		}
 	}
+	// Choosing the radio as the receive device opens its stream, and choosing
+	// anything else closes it. Done HERE rather than left to the next restart:
+	// a device chosen in a dropdown that only takes effect after a relaunch
+	// reads as a device that does not work.
+	// The transmit source follows the "To radio" device, and is applied now:
+	// the radio is told which input to use at the moment it is keyed, so the
+	// setting has to be right before the next message rather than after the
+	// next restart.
+	a.applyTCITXSource()
+	if s.FromRadio == audio.NetworkDeviceID {
+		a.startTCIRecording()
+	} else if a.tciAudioAvailable() {
+		_ = a.cat.TCIAudioDo(func(t cat.TCIAudioController) error { return t.StopTCIAudio() })
+	}
 	// Apply device/preroll/enable changes to the running recorder.
 	a.startQSORecorderIfEnabled()
 	// And to a monitor ALREADY RUNNING: the operator is listening while they
@@ -8460,7 +8552,7 @@ func (a *App) startQSORecorderIfEnabled() {
 	// nothing right to point at. The stream is pushed into the recorder instead
 	// — same samples, no sound card in the middle, and no virtual cable to set up.
 	from := cfg.FromRadio
-	a.qsoRecPushed = a.icomNetAudioActive()
+	a.qsoRecPushed = a.icomNetAudioActive() || cfg.FromRadio == audio.NetworkDeviceID
 	if a.qsoRecPushed {
 		from = audio.PushedSource
 	}
@@ -15141,6 +15233,12 @@ func (a *App) reloadCAT() {
 	} else {
 		a.catSig = sig
 	}
+	// Withdraw the radio as an audio output before deciding anything else. The
+	// TCI case below puts it back; every other backend, and a CAT link turned
+	// off entirely, leaves it withdrawn — a voice keyer that still lists a radio
+	// it can no longer reach would play a message to nowhere, and the operator
+	// hears their own PTT click and assumes it went out.
+	a.installTCITXPlayer(false)
 	if !s.Enabled {
 		a.cat.Stop()
 		return
@@ -15190,37 +15288,38 @@ func (a *App) reloadCAT() {
 		yz := cat.NewYaesu(s.YaesuPort, s.YaesuBaud, s.DigitalDefault)
 		yz.SetLowerLines(s.YaesuLowLines)
 		a.cat.Start(yz)
-	case "kenwood":
+	case "kenwood", "elecraft":
 		// Native Kenwood CAT — TS-590/890/990/2000 and everything that speaks the
-		// same dialect (Elecraft K3/K4, and the "Kenwood" setting on other rigs).
+		// same dialect, the Elecraft K3/K4 included: the K3 emulates the Kenwood
-		// One IF; frame carries frequency, mode, VFO and split, so the poll costs a
+		// command set, so one transport serves both and the Elecraft flag only
-		// single round trip where OmniRig needed a rig file to describe each one.
+		// turns on its specifics (digital modes → DATA A via MD6+DT0).
-		// A network address wins over the COM port when both are filled: it is the
+		elecraft := s.Backend == "elecraft"
-		// more deliberate setting, and silently preferring the wire would leave an
+		switch kenwoodLinkOr(s.KenwoodLink, s.KenwoodHost) {
-		// operator staring at a host they typed and a radio that never answers.
+		case kenwoodLinkNative:
-		if h := strings.TrimSpace(s.KenwoodHost); h != "" {
+			// The radio's OWN network protocol — a session, its own framing, its
-			kw := cat.NewKenwoodTCP(h, s.DigitalDefault)
+			// own authentication. Nothing here speaks it: it is not the CAT byte
+			// stream with a socket in front, and pretending otherwise would open a
+			// connection that answers nothing and blame the radio for it.
+			applog.Printf("cat: %s over the radio's own network protocol is not implemented — use USB, or an RS-232-to-Ethernet bridge", s.Backend)
+			a.cat.Stop()
+			// Said on screen as well as in the log: a CAT panel that simply
+			// stays disconnected sends the operator hunting a cable.
+			if a.ctx != nil {
+				wruntime.EventsEmit(a.ctx, "cat:state", cat.RigState{
+					Error: "this radio's own network protocol is not supported yet — use USB, or an RS-232-to-Ethernet bridge",
+				})
+			}
+			return
+		case kenwoodLinkBridge:
+			kw := cat.NewKenwoodTCP(strings.TrimSpace(s.KenwoodHost), s.DigitalDefault)
 			kw.SetDataMode(s.KenwoodDataMode)
+			kw.SetElecraft(elecraft)
 			a.cat.Start(kw)
-		} else {
+		default:
 			kw := cat.NewKenwood(s.KenwoodPort, s.KenwoodBaud, s.DigitalDefault)
 			kw.SetLowerLines(s.KenwoodLowLines)
 			kw.SetDataMode(s.KenwoodDataMode)
-			a.cat.Start(kw)
+			kw.SetElecraft(elecraft)
-		}
-	case "elecraft":
-		// Elecraft K3/K4: the Kenwood-dialect client with the Elecraft specifics on
-		// (digital modes → DATA A via MD6+DT0). Reuses the Kenwood port/baud/host
-		// settings — the K3 emulates the Kenwood command set, so a separate transport
-		// would be a near-total duplicate.
-		if h := strings.TrimSpace(s.KenwoodHost); h != "" {
-			kw := cat.NewKenwoodTCP(h, s.DigitalDefault)
-			kw.SetElecraft(true)
-			a.cat.Start(kw)
-		} else {
-			kw := cat.NewKenwood(s.KenwoodPort, s.KenwoodBaud, s.DigitalDefault)
-			kw.SetLowerLines(s.KenwoodLowLines)
-			kw.SetElecraft(true)
 			a.cat.Start(kw)
 		}
 	case "icom":
@@ -15267,6 +15366,9 @@ func (a *App) reloadCAT() {
 		// app_tci_rec.go. Armed after the backend is up, since it is the
 		// backend that carries the stream.
 		defer a.startTCIRecording()
+		// And the other direction: the voice keyer can send its messages over
+		// the same link — see app_tci_dvk.go.
+		defer a.installTCITXPlayer(true)
 		tb := cat.NewTCI(s.TCIHost, s.TCIPort, s.DigitalDefault, s.TCISpots)
 		// Clicking one of our spots on the ExpertSDR panorama fills the entry form.
 		tb.OnSpotClick = func(call string, hz int64) {
@@ -15385,6 +15487,9 @@ func (a *App) GetListsSettings() (ListsSettings, error) {
 	if raw, _ := a.settings.Get(a.ctx, keyListsRSTDigital); raw != "" {
 		_ = json.Unmarshal([]byte(raw), &out.RSTDigital)
 	}
+	if raw, _ := a.settings.Get(a.ctx, keyListsSatellites); raw != "" {
+		_ = json.Unmarshal([]byte(raw), &out.Satellites)
+	}
 	if len(out.Bands) == 0 {
 		out.Bands = append([]string(nil), defaultBands...)
 	}
@@ -15400,6 +15505,10 @@ func (a *App) GetListsSettings() (ListsSettings, error) {
 	if len(out.RSTDigital) == 0 {
 		out.RSTDigital = append([]string(nil), defaultRSTDigital...)
 	}
+	// Satellites are NOT defaulted to a shipped list. An empty list means the
+	// station does not work satellites, and filling it with two dozen birds
+	// nobody here has heard would make the field harder to use, not easier —
+	// the operator adds the ones they actually work.
 	return out, nil
 }
 
@@ -15439,6 +15548,14 @@ func (a *App) SaveListsSettings(l ListsSettings) error {
 	// cache, so a band ticked here has to reach that cache now — otherwise it
 	// takes effect at the next restart, which looks like the option not working.
 	a.refreshChaseBands()
+	sat, err := json.Marshal(l.Satellites)
+	if err != nil {
+		return err
+	}
+	if err := a.settings.Set(a.ctx, keyListsSatellites, string(sat)); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -17651,6 +17768,12 @@ type AntGeniusSettings struct {
 	Enabled  bool   `json:"enabled"`
 	Host     string `json:"host"`
 	Password string `json:"password"` // remote-access password; leave blank on LAN (no AUTH)
+	// UseForMyAntenna stamps the SELECTED antenna's name into MY_ANTENNA on
+	// every QSO logged, ahead of the band default from Operating conditions.
+	UseForMyAntenna bool `json:"use_for_my_antenna"`
+	// Ant1Port says which switch port the radio's ANT1 jack is wired to
+	// (1 = A, 2 = B). Station wiring; neither device can report it.
+	Ant1Port int `json:"ant1_port"`
 }
 
 // GetAntGeniusSettings returns the persisted Antenna Genius config.
@@ -17659,13 +17782,19 @@ func (a *App) GetAntGeniusSettings() (AntGeniusSettings, error) {
 	if a.settings == nil {
 		return out, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyAntGeniusEnabled, keyAntGeniusHost, keyAntGeniusPassword)
+	m, err := a.settings.GetMany(a.ctx, keyAntGeniusEnabled, keyAntGeniusHost, keyAntGeniusPassword,
+		keyAntGeniusMyAnt, keyAntGeniusPortForA1)
 	if err != nil {
 		return out, err
 	}
 	out.Enabled = m[keyAntGeniusEnabled] == "1"
 	out.Host = m[keyAntGeniusHost]
 	out.Password = m[keyAntGeniusPassword]
+	out.UseForMyAntenna = m[keyAntGeniusMyAnt] == "1"
+	out.Ant1Port = 1
+	if m[keyAntGeniusPortForA1] == "2" {
+		out.Ant1Port = 2
+	}
 	return out, nil
 }
 
@@ -17675,9 +17804,11 @@ func (a *App) SaveAntGeniusSettings(s AntGeniusSettings) error {
 		return fmt.Errorf("db not initialized")
 	}
 	for k, v := range map[string]string{
-		keyAntGeniusEnabled:  boolStr(s.Enabled),
+		keyAntGeniusEnabled:   boolStr(s.Enabled),
-		keyAntGeniusHost:     strings.TrimSpace(s.Host),
+		keyAntGeniusHost:      strings.TrimSpace(s.Host),
-		keyAntGeniusPassword: s.Password,
+		keyAntGeniusPassword:  s.Password,
+		keyAntGeniusMyAnt:     boolStr(s.UseForMyAntenna),
+		keyAntGeniusPortForA1: map[bool]string{true: "2", false: "1"}[s.Ant1Port == 2],
 	} {
 		if err := a.settings.Set(a.ctx, k, v); err != nil {
 			return err
@@ -19944,7 +20075,27 @@ func (a *App) IsNewUSCounty(state, cnty string) bool {
 // native ones: an operator on OmniRig or Flex gets the same server.
 type catShareRig struct{ a *App }
 
-func (r catShareRig) Freq() int64  { return r.a.cat.State().FreqHz }
+// Freq is what a rigctl client gets for "f": the frequency of the VFO in use,
+// which is where we LISTEN.
+//
+// This returned FreqHz, and RigState follows ADIF where FreqHz is the TRANSMIT
+// frequency — so with split on, every client asking "what frequency is the
+// radio on" was told VFO B. Reported from a station running an IC-7850: turning
+// VFO B moved VFO A. Nothing in OpsLog was writing to the radio; a client was
+// reading the dial, being handed the wrong VFO, and writing it back.
+//
+// The split TX frequency is a separate question, and Hamlib has a separate
+// command for it ("i" / get_split_freq) which Split() below answers.
+func (r catShareRig) Freq() int64 { return shareRXFreq(r.a.cat.State()) }
+
+// shareRXFreq is that rule on its own, so it can be pinned by a test: it is one
+// line, it was wrong, and being wrong cost a station its VFO A.
+func shareRXFreq(st cat.RigState) int64 {
+	if st.Split && st.RxFreqHz > 0 {
+		return st.RxFreqHz
+	}
+	return st.FreqHz
+}
 func (r catShareRig) Mode() string { return r.a.cat.State().Mode }
 
 // Split reports the flag and the OTHER VFO's frequency. RigState follows ADIF —
@@ -20341,8 +20492,6 @@ func clampSpotMax(n int) int {
 	return n
 }
 
-
-
 // GetSpotTTLMinutes returns how long a spot stays in the list, in minutes.
 // 0 means spots are kept until the count cap pushes them out, which is what
 // OpsLog always did.

app_k3.go

@@ -80,6 +80,11 @@ func (a *App) SetKenwoodXIT(on bool) error {
 	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodXIT(on) })
 }
 
+// NudgeKenwoodRIT moves the RIT/XIT offset by delta Hz.
+func (a *App) NudgeKenwoodRIT(delta int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.NudgeKenwoodRIT(delta) })
+}
+
 // ClearKenwoodRIT zeroes the RIT and XIT offsets together, which is what the
 // radio's own RC does and what an operator means by "clear it".
 func (a *App) ClearKenwoodRIT() error {

app_tci_audio.go

@@ -1,53 +0,0 @@
-package main
-
-// TCI receive audio — bindings.
-//
-// A SunSDR carries its receive audio on the same WebSocket as its commands, so
-// OpsLog can take it directly instead of asking the operator to install a
-// virtual audio cable and wire ExpertSDR's output into it. This is the first
-// half: RECEIVE only, which is what the QSO recorder and the CW decoder need.
-// Transmit audio (the voice keyer) is the other half and is not here yet — it
-// has to answer the radio's chrono packets at the right pace, and that is worth
-// doing once the receive side has proved the format on a real radio.
-
-import (
-	"fmt"
-
-	"hamlog/internal/applog"
-	"hamlog/internal/cat"
-)
-
-// StartTCIAudio opens the receive-audio stream for one receiver.
-//
-// rate 0 means 48 kHz, which is what ExpertSDR streams by default and what the
-// recorder wants anyway.
-func (a *App) StartTCIAudio(rx, rate int) error {
-	if a.cat == nil {
-		return fmt.Errorf("CAT not initialized")
-	}
-	applog.Printf("tci: opening the receive-audio stream (rx %d, %d Hz)", rx, rate)
-	return a.cat.TCIAudioDo(func(t cat.TCIAudioController) error { return t.StartTCIAudio(rx, rate) })
-}
-
-// StopTCIAudio closes it.
-func (a *App) StopTCIAudio() error {
-	if a.cat == nil {
-		return fmt.Errorf("CAT not initialized")
-	}
-	applog.Printf("tci: closing the receive-audio stream")
-	return a.cat.TCIAudioDo(func(t cat.TCIAudioController) error { return t.StopTCIAudio() })
-}
-
-// GetTCIAudioStatus reports what is arriving: the sample rate the radio chose,
-// how much has come in, and the peak level of the last second.
-//
-// The level is the point. "The stream is open" and "audio is arriving" are
-// different claims, and only the second one is worth anything to someone
-// testing this on a radio for the first time.
-func (a *App) GetTCIAudioStatus() cat.TCIAudioStatus {
-	if a.cat == nil {
-		return cat.TCIAudioStatus{}
-	}
-	st, _ := a.cat.TCIAudioState()
-	return st
-}

app_tci_dvk.go

@@ -0,0 +1,86 @@
+package main
+
+// The voice keyer, through the radio's own link.
+//
+// Selecting the radio as the "To radio" output makes the voice keyer hand its
+// messages to the CAT backend instead of a sound card. Everything around it is
+// unchanged — the same PTT before and after, the same gain, the same files —
+// which is the point: the audio takes a different road, not a different route.
+
+import (
+	"fmt"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/audio"
+	"hamlog/internal/cat"
+)
+
+// tciTXPlayer hands one message to the radio.
+//
+// The controller is fetched on the CAT goroutine and the message is then played
+// OFF it. Playing on it would hold that goroutine for the length of the
+// message, and everything else about the rig — frequency, mode, PTT state —
+// goes through the same place: a ten-second call would freeze the display and
+// the antenna following for ten seconds. The TCI backend serialises its own
+// writes, so this is safe to call from here.
+func (a *App) tciTXPlayer(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	type txPlayer interface {
+		PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error
+	}
+	var player txPlayer
+	err := a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
+		p, ok := t.(txPlayer)
+		if !ok {
+			return fmt.Errorf("this radio cannot take transmit audio over its CAT link")
+		}
+		player = p
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return player.PlayTXAudio(pcm, rate, ch, bits, stop)
+}
+
+// applyTCITXSource tells the radio where to take its transmit audio from,
+// following the "To radio" device.
+//
+// This is the setting an operator would otherwise have to find in ExpertSDR3
+// and set again for every mode, because it is remembered per mode there. It is
+// the third argument of TRX, so OpsLog can simply say it each time it keys —
+// and a radio told nothing keeps the operator's microphone, which is what
+// every PTT that is not a voice message should do.
+func (a *App) applyTCITXSource() {
+	if a.cat == nil {
+		return
+	}
+	cfg, _ := a.GetAudioSettings()
+	src := ""
+	if cfg.ToRadio == audio.NetworkDeviceID {
+		src = "tci"
+	}
+	_ = a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
+		if s, ok := t.(interface{ SetTXAudioSource(string) }); ok {
+			s.SetTXAudioSource(src)
+		}
+		return nil
+	})
+}
+
+// installTCITXPlayer offers the radio as an audio output, or withdraws it.
+//
+// Withdrawing matters as much as offering: a radio that has gone away must stop
+// being a device the voice keyer will happily "play" to, or a message goes
+// nowhere and the operator hears their own PTT click and assumes it worked.
+func (a *App) installTCITXPlayer(on bool) {
+	if !on {
+		audio.SetNetworkPlayer(nil)
+		return
+	}
+	audio.SetNetworkPlayer(a.tciTXPlayer)
+	a.applyTCITXSource()
+	applog.Printf("tci: the radio is available as an audio output — no virtual cable needed for the voice keyer")
+}

app_tci_rec.go

@@ -68,10 +68,18 @@ func tciToRecorderPCM(rate int, samples []float32) []byte {
 // startTCIRecording opens the receive stream and routes it to the recorder.
 //
 // Called when the TCI backend comes up, and only when the operator has asked
-// for it: opening a 384 kB/s stream on a station that records nothing is work
+// for it by choosing the radio as their receive device: opening a 384 kB/s
-// the radio does for nobody.
+// stream on a station that records nothing is work the radio does for nobody.
 func (a *App) startTCIRecording() {
-	if a.cat == nil || a.settingOr(keyTCIRecAudio, "") != "1" {
+	if a.cat == nil {
+		return
+	}
+	// One switch, and it is the one an operator is already looking at: the
+	// "From radio" device. There used to be a tick box here as well, from when
+	// this was an experiment with no device to choose — two controls for one
+	// question, and the second was where nobody would look.
+	cfg, _ := a.GetAudioSettings()
+	if cfg.FromRadio != audio.NetworkDeviceID {
 		return
 	}
 	err := a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
@@ -88,33 +96,3 @@ func (a *App) startTCIRecording() {
 	}
 	applog.Printf("tci: recording the receive audio over TCI — no virtual cable needed")
 }
-
-// keyTCIRecAudio turns it on. Off by default: it replaces whatever sound card
-// the operator has already wired up, and a setting that changes where a
-// recording comes from should be asked for rather than assumed.
-const keyTCIRecAudio = "audio.tci_rx"
-
-// GetTCIRecordAudio reports whether the recorder takes its audio from the radio.
-func (a *App) GetTCIRecordAudio() bool { return a.settingOr(keyTCIRecAudio, "") == "1" }
-
-// SetTCIRecordAudio turns it on or off, and applies it NOW rather than at the
-// next restart: an option that needs the application relaunched to take effect
-// reads as an option that does not work.
-func (a *App) SetTCIRecordAudio(on bool) error {
-	a.setSetting(keyTCIRecAudio, boolStr(on))
-	if on {
-		a.startTCIRecording()
-		return nil
-	}
-	if a.cat == nil {
-		return nil
-	}
-	return a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
-		if s, ok := t.(interface {
-			SetTCIAudioSink(func(int, []float32))
-		}); ok {
-			s.SetTCIAudioSink(nil)
-		}
-		return t.StopTCIAudio()
-	})
-}

app_tci_record.go

@@ -1,175 +0,0 @@
-package main
-
-// Recording a few seconds of the TCI stream to a WAV file.
-//
-// Counting frames proves a socket is delivering bytes. It does not prove those
-// bytes are the receiver's audio, at the right rate, in the right order — a
-// stream decoded with the channels swapped, the width wrong or the samples
-// misaligned counts exactly as well as a correct one and sounds like a fan.
-//
-// So the test is a file the operator can play. It is the same reason the CW
-// decoder was validated on the air rather than on a spectrogram.
-
-import (
-	"encoding/binary"
-	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-
-	"hamlog/internal/applog"
-	"hamlog/internal/cat"
-)
-
-// tciRec collects samples while a test recording is running.
-type tciRec struct {
-	mu      sync.Mutex
-	active  bool
-	rate    int
-	samples []float32
-	want    int // how many samples to collect before stopping
-}
-
-var tciRecorder tciRec
-
-// RecordTCIAudio captures seconds of the TCI receive stream and writes a WAV
-// next to the QSO recordings. Returns the path.
-//
-// The stream has to be open already — this listens to what is arriving rather
-// than opening anything, so a recording can never leave a stream running that
-// the operator did not ask for.
-func (a *App) RecordTCIAudio(seconds int) (string, error) {
-	if a.cat == nil {
-		return "", fmt.Errorf("CAT not initialized")
-	}
-	if seconds <= 0 || seconds > 60 {
-		seconds = 10
-	}
-
-	// Rate from the radio, not assumed: the file's header has to match what was
-	// actually streamed or the recording plays at the wrong speed, which is the
-	// one fault that would be blamed on the decoding.
-	st := a.GetTCIAudioStatus()
-	if !st.Running {
-		return "", fmt.Errorf("open the TCI audio stream first")
-	}
-	rate := st.SampleRate
-	if rate <= 0 {
-		rate = 48000
-	}
-
-	tciRecorder.mu.Lock()
-	if tciRecorder.active {
-		tciRecorder.mu.Unlock()
-		return "", fmt.Errorf("a test recording is already running")
-	}
-	tciRecorder.active = true
-	tciRecorder.rate = rate
-	tciRecorder.want = rate * seconds
-	tciRecorder.samples = make([]float32, 0, tciRecorder.want)
-	tciRecorder.mu.Unlock()
-
-	err := a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
-		s, ok := t.(interface{ SetTCIAudioSink(func(int, []float32)) })
-		if !ok {
-			return fmt.Errorf("this backend has no audio sink")
-		}
-		s.SetTCIAudioSink(func(_ int, samples []float32) {
-			tciRecorder.mu.Lock()
-			defer tciRecorder.mu.Unlock()
-			if !tciRecorder.active {
-				return
-			}
-			tciRecorder.samples = append(tciRecorder.samples, samples...)
-		})
-		return nil
-	})
-	if err != nil {
-		tciRecorder.mu.Lock()
-		tciRecorder.active = false
-		tciRecorder.mu.Unlock()
-		return "", err
-	}
-
-	// Wait for the samples rather than for the clock: a stream that stalls
-	// halfway should produce a short file that says so, not a long one padded
-	// with silence that hides it.
-	deadline := time.Now().Add(time.Duration(seconds+5) * time.Second)
-	for {
-		tciRecorder.mu.Lock()
-		got := len(tciRecorder.samples)
-		want := tciRecorder.want
-		tciRecorder.mu.Unlock()
-		if got >= want || time.Now().After(deadline) {
-			break
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-
-	tciRecorder.mu.Lock()
-	tciRecorder.active = false
-	pcm := tciRecorder.samples
-	tciRecorder.samples = nil
-	tciRecorder.mu.Unlock()
-	_ = a.cat.TCIAudioDo(func(t cat.TCIAudioController) error {
-		if s, ok := t.(interface{ SetTCIAudioSink(func(int, []float32)) }); ok {
-			s.SetTCIAudioSink(nil)
-		}
-		return nil
-	})
-
-	if len(pcm) == 0 {
-		return "", fmt.Errorf("nothing arrived on the stream")
-	}
-	path := filepath.Join(a.qsoRecDir(), fmt.Sprintf("tci-test-%s.wav", time.Now().Format("20060102-150405")))
-	if err := writeMonoWAV(path, pcm, rate); err != nil {
-		return "", err
-	}
-	applog.Printf("tci: wrote %.1f s of receive audio to %s (%d Hz)", float64(len(pcm))/float64(rate), path, rate)
-	return path, nil
-}
-
-// writeMonoWAV writes float samples as 16-bit mono PCM.
-//
-// Its own writer rather than internal/audio's: that one is nailed to the voice
-// keyer's rate, and a test recording written at the wrong rate would play back
-// at the wrong speed — the one fault that looks exactly like a decoding error.
-func writeMonoWAV(path string, samples []float32, rate int) error {
-	data := make([]byte, len(samples)*2)
-	for i, v := range samples {
-		s := int(math.Round(float64(v) * 32767))
-		if s > 32767 {
-			s = 32767
-		}
-		if s < -32768 {
-			s = -32768
-		}
-		binary.LittleEndian.PutUint16(data[i*2:], uint16(int16(s)))
-	}
-	var hdr [44]byte
-	copy(hdr[0:], "RIFF")
-	binary.LittleEndian.PutUint32(hdr[4:], uint32(36+len(data)))
-	copy(hdr[8:], "WAVEfmt ")
-	binary.LittleEndian.PutUint32(hdr[16:], 16) // PCM chunk size
-	binary.LittleEndian.PutUint16(hdr[20:], 1)  // PCM
-	binary.LittleEndian.PutUint16(hdr[22:], 1)  // mono
-	binary.LittleEndian.PutUint32(hdr[24:], uint32(rate))
-	binary.LittleEndian.PutUint32(hdr[28:], uint32(rate*2))
-	binary.LittleEndian.PutUint16(hdr[32:], 2)  // block align
-	binary.LittleEndian.PutUint16(hdr[34:], 16) // bits
-	copy(hdr[36:], "data")
-	binary.LittleEndian.PutUint32(hdr[40:], uint32(len(data)))
-
-	f, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-	if _, err := f.Write(hdr[:]); err != nil {
-		return err
-	}
-	_, err = f.Write(data)
-	return err
-}

bootlog.go

@@ -0,0 +1,226 @@
+package main
+
+// The first breadcrumbs, written before anything else can fail.
+//
+// OpsLog keeps its log in the data folder, which lives beside the executable —
+// so every fault that happens BEFORE that folder exists is invisible. Reported
+// from a Windows 10 machine: "the process appears, no data folder is created,
+// nothing starts", with no file anywhere to say why. There was nothing to read
+// because the only place we write to had not been created yet.
+//
+// This writes to %LOCALAPPDATA%\OpsLog\startup.log instead: a folder Windows
+// guarantees is writable for the user, whatever OpsLog itself was installed
+// into. It records the handful of milestones between the process starting and
+// the window appearing, and nothing else — it is not a second log, it is the
+// answer to "it does not start".
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+// bootLogPath is the file, or "" when even LOCALAPPDATA is unavailable.
+func bootLogPath() string {
+	dir := os.Getenv("LOCALAPPDATA")
+	if strings.TrimSpace(dir) == "" {
+		dir = os.TempDir()
+	}
+	if dir == "" {
+		return ""
+	}
+	dir = filepath.Join(dir, "OpsLog")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return ""
+	}
+	return filepath.Join(dir, "startup.log")
+}
+
+// bootLog appends one line. Never fails loudly: it exists to explain a failure,
+// so it must not become one.
+func bootLog(format string, args ...any) {
+	p := bootLogPath()
+	if p == "" {
+		return
+	}
+	f, err := os.OpenFile(p, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	// Trimmed when it gets long. A startup log that grows for two years is a
+	// file nobody opens, and the interesting launch is always the last one.
+	if fi, err := f.Stat(); err == nil && fi.Size() > 256*1024 {
+		f.Close()
+		_ = os.Remove(p)
+		f, err = os.OpenFile(p, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+		if err != nil {
+			return
+		}
+		defer f.Close()
+	}
+	fmt.Fprintf(f, "%s %s\n", time.Now().Format("2006-01-02 15:04:05.000"), fmt.Sprintf(format, args...))
+}
+
+// bootLogLaunch records what was launched and from where.
+func bootLogLaunch() {
+	exe, _ := os.Executable()
+	bootLog("launch: %s %v", exe, os.Args[1:])
+}
+
+// checkDataDirWritable makes sure the folder OpsLog keeps everything in can
+// actually be created and written to, and says exactly what failed if not.
+//
+// The data folder sits beside the executable, which is fine on a stick or in a
+// home directory and refused outright under Program Files — where Windows
+// silently denies the write to anything not elevated. That refusal used to end
+// the launch with no window and no message.
+func checkDataDirWritable() error {
+	dir, err := userDataDir()
+	if err != nil {
+		return fmt.Errorf("cannot work out where to keep the data: %w", err)
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return fmt.Errorf("cannot create the data folder %s: %w", dir, err)
+	}
+	probe := filepath.Join(dir, ".writetest")
+	if err := os.WriteFile(probe, []byte("ok"), 0o644); err != nil {
+		return fmt.Errorf("the data folder %s cannot be written to: %w", dir, err)
+	}
+	_ = os.Remove(probe)
+	bootLog("data dir ok: %s", dir)
+	return nil
+}
+
+// startupReached flips as soon as OnStartup runs — the first moment OpsLog's
+// own code is executing inside the window's lifecycle.
+var startupReached atomic.Bool
+
+// startupStuckMessage is what an operator sees when the window never starts.
+//
+// It names the two causes and what to do about each, because "OpsLog is not
+// responding" sends people to reinstall OpsLog, which is the one thing that
+// cannot help: the part that has not started is not ours.
+const startupStuckMessage = "OpsLog started but its window never opened.\n\n" +
+	"This is the WebView2 runtime failing to start, and it is almost always one of two things:\n\n" +
+	"• The Microsoft Edge WebView2 Runtime is missing — install it from Microsoft, then start OpsLog again.\n" +
+	"• An antivirus is blocking msedgewebview2.exe — add OpsLog's folder to its exceptions.\n\n" +
+	"The details are in the OpsLog folder under LOCALAPPDATA (startup.log)."
+
+// webviewDataPath is where WebView2 keeps its profile.
+//
+// Named rather than left to the default, which lands in the ROAMING profile: on
+// a managed account that folder can be redirected to a network share, and a
+// WebView2 profile on a share that is slow or unreachable does not fail — it
+// hangs, which is indistinguishable from a runtime that will not start.
+//
+// It also gives the folder a name someone can be told to delete: a corrupt
+// profile is a real cause of this, and "delete this folder and try again" is
+// only advice if the folder can be pointed at.
+func webviewDataPath() string {
+	dir := os.Getenv("LOCALAPPDATA")
+	if strings.TrimSpace(dir) == "" {
+		return "" // let Wails decide; there is nothing better to offer
+	}
+	p := filepath.Join(dir, "OpsLog", "WebView2")
+	if err := os.MkdirAll(p, 0o755); err != nil {
+		bootLog("WebView2 profile folder %s could not be created: %v — leaving it to Wails", p, err)
+		return ""
+	}
+	return p
+}
+
+// stuckMarkerPath is written before the window is attempted and removed once it
+// opens, so the NEXT launch can tell that the last one never got there.
+func stuckMarkerPath() string {
+	dir := os.Getenv("LOCALAPPDATA")
+	if strings.TrimSpace(dir) == "" {
+		dir = os.TempDir()
+	}
+	return filepath.Join(dir, "OpsLog", ".launching")
+}
+
+// lastLaunchHung is set at startup from the marker left by the previous run.
+var lastLaunchHung bool
+
+// noteLaunchAttempt records that a window is about to be attempted, and reports
+// whether the previous attempt ever finished.
+func noteLaunchAttempt() {
+	p := stuckMarkerPath()
+	if _, err := os.Stat(p); err == nil {
+		lastLaunchHung = true
+		bootLog("the previous launch never opened its window — trying again with GPU acceleration off")
+	}
+	_ = os.MkdirAll(filepath.Dir(p), 0o755)
+	_ = os.WriteFile(p, []byte(time.Now().Format(time.RFC3339)), 0o644)
+}
+
+// clearLaunchMarker is called once the window is up: the attempt finished.
+func clearLaunchMarker() { _ = os.Remove(stuckMarkerPath()) }
+
+// fixedWebView2Path finds a FIXED-VERSION WebView2 runtime shipped beside
+// OpsLog, or "" when there is none.
+//
+// Microsoft publishes the runtime in two forms. Evergreen installs itself into
+// Windows and updates itself — the normal case, and the one this looks for
+// first. FIXED VERSION is a folder of files an application carries with it and
+// points at, needing no installation and no administrator: it exists precisely
+// for machines where Evergreen cannot be installed, which is not a rare
+// situation on a managed, offline or otherwise locked-down Windows.
+//
+// So: drop the extracted folder next to OpsLog.exe and it is used. Nothing to
+// configure — a setting for this would be a question asked of the one operator
+// least able to answer it, on a machine where nothing starts.
+func fixedWebView2Path() string {
+	exe, err := os.Executable()
+	if err != nil {
+		return ""
+	}
+	base := filepath.Dir(exe)
+	for _, name := range []string{"WebView2", "WebView2Runtime", "webview2"} {
+		dir := filepath.Join(base, name)
+		if p := findWebView2Binary(dir); p != "" {
+			bootLog("using the fixed-version WebView2 runtime in %s", p)
+			return p
+		}
+	}
+	return ""
+}
+
+// findWebView2Binary returns dir (or its single versioned subfolder) when it
+// holds msedgewebview2.exe — the fixed-version download unpacks with the
+// version as a folder level, and asking someone to flatten it by hand is one
+// more step to get wrong.
+func findWebView2Binary(dir string) string {
+	if fileExists(filepath.Join(dir, "msedgewebview2.exe")) {
+		return dir
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return ""
+	}
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		sub := filepath.Join(dir, e.Name())
+		if fileExists(filepath.Join(sub, "msedgewebview2.exe")) {
+			return sub
+		}
+	}
+	return ""
+}
+
+// edgeBlockedMessage is shown when an Edge blocker is found in the way.
+//
+// It names the tool rather than the symptom: OpsLog draws its whole interface
+// with the WebView2 engine, which is Edge's, so a machine where Edge is blocked
+// cannot run it — and no amount of reinstalling OpsLog will change that.
+const edgeBlockedMessage = "OpsLog cannot start because Edge is blocked on this PC.\n\n" +
+	"A blocker tool (or a policy) is stopping msedgewebview2.exe from running. " +
+	"OpsLog draws its whole interface with that engine, so it cannot open its window.\n\n" +
+	"Unblock Edge — in the tool that blocked it — and start OpsLog again. " +
+	"The details are in the OpsLog folder under LOCALAPPDATA (startup.log)."

catlink.go

@@ -0,0 +1,34 @@
+package main
+
+// How a Kenwood-dialect radio is reached.
+//
+// Three transports, and they are genuinely different things rather than three
+// spellings of one: a COM port, the same CAT bytes carried over TCP by a serial
+// bridge, and the radio's own network protocol — which is a session with its own
+// framing and authentication, and is not implemented here.
+//
+// Kept as an explicit setting rather than inferred from which field an operator
+// happened to fill in. The old code preferred a network address whenever one was
+// present, which is invisible from the settings page: someone who typed a host
+// months ago, then set a COM port, had a radio that never answered and nothing
+// on screen to explain it.
+
+const (
+	kenwoodLinkUSB    = "usb"    // a COM port
+	kenwoodLinkBridge = "bridge" // RS-232 to Ethernet: the same CAT bytes over TCP
+	kenwoodLinkNative = "native" // the radio's own network protocol — not supported
+)
+
+// kenwoodLinkOr resolves the stored choice, falling back to what an older
+// install can be read as: a configured host meant the bridge, because that is
+// what the previous code used it for.
+func kenwoodLinkOr(link, host string) string {
+	switch link {
+	case kenwoodLinkUSB, kenwoodLinkBridge, kenwoodLinkNative:
+		return link
+	}
+	if host != "" {
+		return kenwoodLinkBridge
+	}
+	return kenwoodLinkUSB
+}

catlink_test.go

@@ -0,0 +1,33 @@
+package main
+
+import "testing"
+
+// The transport is a stored choice now, but installs exist that predate it and
+// hold only a host. Reading those as "bridge" is what keeps a working station
+// working across the upgrade — the old code used a host for exactly that.
+func TestTheLinkIsReadFromAnOlderInstall(t *testing.T) {
+	cases := []struct {
+		link, host, want string
+	}{
+		{"", "", kenwoodLinkUSB},                              // nothing configured
+		{"", "192.168.1.50:4999", kenwoodLinkBridge},          // upgraded: host only
+		{kenwoodLinkUSB, "192.168.1.50:4999", kenwoodLinkUSB}, // chose USB, host left behind
+		{kenwoodLinkBridge, "", kenwoodLinkBridge},
+		{kenwoodLinkNative, "", kenwoodLinkNative},
+		{"nonsense", "", kenwoodLinkUSB}, // a value nobody wrote: fall back, don't guess
+	}
+	for _, c := range cases {
+		if got := kenwoodLinkOr(c.link, c.host); got != c.want {
+			t.Errorf("link=%q host=%q → %q, want %q", c.link, c.host, got, c.want)
+		}
+	}
+}
+
+// The one that matters after the fact: an operator who picks USB while an old
+// host is still stored must get the COM port. The previous code preferred the
+// host whenever it was non-empty, which is invisible from the settings page.
+func TestChoosingUSBBeatsALeftoverHost(t *testing.T) {
+	if got := kenwoodLinkOr(kenwoodLinkUSB, "10.0.0.9:4999"); got != kenwoodLinkUSB {
+		t.Fatalf("a leftover host overrode the operator's choice: %q", got)
+	}
+}

catshare_freq_test.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"testing"
+
+	"hamlog/internal/cat"
+)
+
+// What a rigctl client is told when it asks "what frequency is the radio on".
+//
+// Hamlib's "f" means the VFO IN USE — where the operator is listening. RigState
+// follows ADIF, where FreqHz is where we TRANSMIT, and the two are the same
+// number until split is engaged. They were handed over unchanged, so with split
+// on every client asking for the dial was given VFO B.
+//
+// Reported from a station running an IC-7850 over USB: turning VFO B moved
+// VFO A. OpsLog was writing nothing to that radio — a client read the dial, was
+// handed the transmit VFO, and wrote it back as the dial.
+func TestShareRXFreqAnswersTheListeningVFO(t *testing.T) {
+	const rx, tx = 14195000, 14200500
+	cases := []struct {
+		name string
+		st   cat.RigState
+		want int64
+	}{
+		{
+			name: "simplex — the one frequency there is",
+			st:   cat.RigState{FreqHz: rx},
+			want: rx,
+		},
+		{
+			name: "split — the RX VFO, not the TX one",
+			st:   cat.RigState{Split: true, FreqHz: tx, RxFreqHz: rx},
+			want: rx,
+		},
+		{
+			// A backend that reports split without ever filling RxFreqHz would
+			// otherwise be answered with 0, and a client told the radio is on
+			// 0 Hz does something worse than nothing with it.
+			name: "split claimed but no RX frequency known",
+			st:   cat.RigState{Split: true, FreqHz: tx},
+			want: tx,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := shareRXFreq(c.st); got != c.want {
+				t.Errorf("shareRXFreq(%+v) = %d, want %d", c.st, got, c.want)
+			}
+		})
+	}
+}
+
+// And the pair, stated together: the two questions must not return the same
+// answer while split is on, or the distinction has been lost somewhere.
+func TestShareSplitReportsTheOtherVFO(t *testing.T) {
+	st := cat.RigState{Split: true, FreqHz: 14200500, RxFreqHz: 14195000}
+	rxAnswer := shareRXFreq(st)
+	txAnswer := st.FreqHz // what Split() hands back for "i" / get_split_freq
+	if rxAnswer == txAnswer {
+		t.Fatalf("get_freq and get_split_freq both answered %d — a client cannot tell the VFOs apart", rxAnswer)
+	}
+	if rxAnswer != st.RxFreqHz || txAnswer != st.FreqHz {
+		t.Errorf("got rx=%d tx=%d, want rx=%d tx=%d", rxAnswer, txAnswer, st.RxFreqHz, st.FreqHz)
+	}
+}

changelog.json

@@ -1,9 +1,93 @@
 [
+  {
+    "version": "0.26.17",
+    "date": "",
+    "en": [
+      "Awards, RDA district comparison: each disagreement can now be settled on its own row. Click the district you keep — the log's or the database's — and apply. It is written into the contact's CNTY and its award reference, and the settled rows leave the list.",
+      "The band/mode matrix: a confirmed slot now shows as confirmed. A callsign worked and not confirmed was outranking an entity CONFIRMED on the same band and mode, so a slot that needs nothing was painted as if it still did.",
+      "CAT sharing: a program connected to OpsLog's rigctl server is told the frequency it is LISTENING on. With split engaged it was given the transmit VFO instead, so a client that reads the dial and writes it back — WSJT-X and its like — could move VFO A when VFO B was turned."
+    ],
+    "fr": [
+      "Diplômes, comparaison des districts RDA : chaque divergence se règle désormais sur sa propre ligne. Cliquer le district qu'on garde — celui du log ou celui de la base — puis appliquer. Il est écrit dans le CNTY du contact et dans sa référence de diplôme, et les lignes réglées quittent la liste.",
+      "Matrice bandes/modes : une case confirmée s'affiche enfin comme confirmée. Un indicatif travaillé et non confirmé l'emportait sur une entité CONFIRMÉE sur la même bande et le même mode, si bien qu'une case qui ne demandait plus rien était peinte comme s'il manquait encore quelque chose.",
+      "Partage CAT : un programme connecté au serveur rigctl d'OpsLog reçoit la fréquence sur laquelle on ÉCOUTE. En split, c'était le VFO d'émission qui lui était donné, si bien qu'un client qui lit le VFO et le réécrit — WSJT-X et consorts — pouvait déplacer le VFO A quand on tournait le VFO B."
+    ]
+  },
+  {
+    "version": "0.26.16",
+    "date": "",
+    "en": [
+      "TCI transmit needs no setting up in ExpertSDR3 any more. The protocol lets the audio source be named when keying, so OpsLog does it — the voice keyer works in SSB as well as in the digital modes, nothing has to be set per mode in the radio's own window, and the microphone stays the source for every transmission that is not a voice message."
+    ],
+    "fr": [
+      "L'émission TCI ne demande plus aucun réglage dans ExpertSDR3. Le protocole permet de nommer la source audio au moment de passer en émission, et OpsLog le fait — le manipulateur vocal fonctionne en SSB comme en numérique, il n'y a plus rien à régler mode par mode dans la fenêtre de la radio, et le micro reste la source pour toute émission qui n'est pas un message vocal."
+    ]
+  },
+  {
+    "version": "0.26.15",
+    "date": "",
+    "en": [
+      "SunSDR / ExpertSDR3: the radio's audio now travels over the TCI link itself. Pick 'Radio (TCI network audio)' as the From Radio or To Radio device and the QSO recorder and the voice keyer work with no virtual cable, no second sound card and nothing to set up in the Windows mixer.",
+      "For transmit, ExpertSDR3's own transmit audio source must be set to TCI rather than the microphone — it is remembered per mode, so setting it in SSB does not set it in DIGU. OpsLog says so within a fifth of a second rather than transmitting silence.",
+      "Awards, RDA district comparison: the list stays where it was put. It was thrown back to the first row every three seconds, which made a long list of contacts to correct impossible to work through.",
+      "Elecraft console: the SWR bar works. The radio answers SW; with three digits in tenths of a ratio — SW023 is 2.3:1 — and OpsLog was reading four, so every answer was discarded and the bar stayed empty."
+    ],
+    "fr": [
+      "SunSDR / ExpertSDR3 : l'audio de la radio passe désormais par la liaison TCI elle-même. Choisis « Radio (TCI network audio) » comme périphérique From Radio ou To Radio et l'enregistreur de QSO comme le manipulateur vocal fonctionnent sans câble virtuel, sans seconde carte son et sans rien à régler dans le mixeur Windows.",
+      "Pour l'émission, la source audio d'émission d'ExpertSDR3 doit être réglée sur TCI et non sur le micro — elle est mémorisée par mode, donc la régler en SSB ne la règle pas en DIGU. OpsLog le dit en deux dixièmes de seconde au lieu d'émettre du silence.",
+      "Diplômes, comparaison des districts RDA : la liste reste où on l'a laissée. Elle revenait à la première ligne toutes les trois secondes, ce qui rendait impraticable une longue liste de contacts à corriger.",
+      "Console Elecraft : la barre de ROS fonctionne. La radio répond à SW; par trois chiffres en dixièmes de rapport — SW023 vaut 2,3:1 — et OpsLog en lisait quatre, si bien que chaque réponse était jetée et la barre restait vide."
+    ]
+  },
+  {
+    "version": "0.26.14",
+    "date": "",
+    "en": [
+      "Elecraft console: the transmit meters are read whenever the RADIO says it is transmitting, not only when OpsLog keyed it. Keying with the front-panel PTT, a footswitch or the mic button left the panel showing a receiver — and the power and SWR bars are read only while transmitting, so for anyone keying by hand they were never read at all.",
+      "Cluster: the list holds still while it is being read. Scrolled away from the top it stops redrawing and shows how many spots are waiting; scrolling back to the top, or clicking the notice, releases it. On a busy evening a spot lands every second or two and the callsign under the pointer had moved by the time the click arrived.",
+      "Cluster command buttons take 500 characters instead of 120. A DXSpider filter listing wanted prefixes runs past a hundred easily, and the field simply stopped accepting keystrokes — saving the command truncated, with nothing to say so.",
+      "Multi-monitor: the saved window position is now checked against the monitors themselves, not the rectangle that spans them. Monitors rarely fill that rectangle, and a window in one of the leftover gaps passed the old test while being invisible. A position that is genuinely lost is moved onto the nearest screen — keeping the window size — instead of being handed back to Windows, and the screen layout is written to the log at every start.",
+      "PowerGenius XL: the amplifier's real state is read at startup. Its status frame carries no 'operate' field — the state is in 'state' — so on the direct GSCP link the flag was never read at all and OpsLog opened claiming STANDBY on an amp that was in line, with the first press of the button then commanding the state it was already in. IDLE means in line, not keyed.",
+      "Antenna Genius: an option to write the SELECTED antenna into MY_ANTENNA, under the name it carries on the switch, ahead of the band default from Operating conditions. Which of the two ports counts is decided by the antenna jack the radio is transmitting on (ANT1/ANT2 on a Flex), with the jack-to-port wiring set once in Preferences — neither device can report it. When the port cannot be told, the log keeps the band default rather than naming an antenna at random.",
+      "The awards tab beside the entry form (F3) now offers only the awards this station follows, and drops the ones switched off — the same list the Awards tab reads. It offered every award that existed, so a station chasing three of them picked references out of a list of twenty.",
+      "CAT settings ask two questions instead of one: WHICH RADIO, then HOW IT IS CONNECTED — and the second only appears where there is a choice to make. OmniRig leads the list, the brands follow alphabetically, and each offers only what it has: USB for a Yaesu or a Xiegu, USB or an RS-232-to-Ethernet bridge for a Kenwood or an Elecraft, USB or its own network protocol for an Icom, and nothing to choose for a FlexRadio or a SunSDR, which are reached one way each. The old list mixed the two questions — 'Icom (USB)' and 'Icom (network)' were separate entries while Kenwood and Elecraft hid the same choice in a field further down — and the example network address named port 4532, which is Hamlib rigctld and the one OpsLog itself serves under Share CAT.",
+      "An editable list of satellites (Preferences → Lists → Satellites). The satellite-name field on the entry form offers them as a dropdown, alphabetically, and still accepts anything typed. SAT_NAME is compared character for character by the awards and by LoTW — AO-91 and AO91 are two different satellites to everything downstream — so a remembered spelling beats one retyped on every pass.",
+      "Awards, RDA district comparison: the conflict list is taller and scrolls, a callsign in it opens the contact, and the compare and fill-districts buttons say they are working. The list was capped at about six visible rows out of two hundred, in a panel that would not scroll to the rest, and nothing in it could be acted on.",
+      "Preferences no longer redraw with the main window. Being a child of the main view, the whole panel was rebuilt on every cluster spot and every CAT update — several times a second on a busy evening — which looked like a page refreshing constantly and made buttons miss their clicks, the element under the pointer being replaced between the press and the release.",
+      "A launch that fails before the window exists now says why, on screen and in a startup log kept outside the data folder. Every fault before that point was invisible — no window, no folder, no file to read — and the causes are named: a missing or blocked WebView2 runtime, an 'Edge blocker' tool stopping the engine OpsLog draws its interface with, a folder Windows refuses to write to, a copy already running. WebView2 also gets its own profile folder on the local disk, retries without GPU acceleration after a launch that hung, and can use a fixed-version runtime dropped beside OpsLog where the installer cannot run."
+    ],
+    "fr": [
+      "Console Elecraft : les mesures d'émission sont lues dès que la RADIO se déclare en émission, et plus seulement quand OpsLog l'a mise en émission. Passer en émission par le PTT de façade, une pédale ou le bouton du micro laissait le panneau croire à une réception — et comme les barres de puissance et de ROS ne sont lues qu'en émission, elles ne l'étaient jamais pour qui manipule à la main.",
+      "Cluster : la liste se fige pendant qu'on la lit. Dès qu'on quitte le haut, elle cesse de se redessiner et indique combien de spots attendent ; revenir en haut, ou cliquer sur l'avis, la relâche. Un soir chargé, un spot tombe toutes les une ou deux secondes et l'indicatif sous le pointeur avait bougé avant que le clic n'arrive.",
+      "Les boutons de commande du cluster acceptent 500 caractères au lieu de 120. Un filtre DXSpider qui énumère des préfixes dépasse la centaine sans peine, et le champ cessait simplement d'accepter les frappes — la commande était enregistrée tronquée, sans un mot.",
+      "Multi-écrans : la position enregistrée est désormais vérifiée contre les écrans eux-mêmes, et non contre le rectangle qui les englobe. Les écrans remplissent rarement ce rectangle, et une fenêtre tombée dans un des trous passait l'ancien test tout en étant invisible. Une position réellement perdue est déplacée sur l'écran le plus proche — en conservant la taille de la fenêtre — au lieu d'être rendue à Windows, et la disposition des écrans est écrite dans le journal à chaque démarrage.",
+      "Power Genius XL : l'état réel de l'amplificateur est lu au démarrage. Sa trame d'état ne contient pas de champ « operate » — l'état est dans « state » — si bien que sur la liaison GSCP directe l'indicateur n'était jamais lu : OpsLog s'ouvrait en annonçant STANDBY sur un ampli en ligne, et le premier appui commandait l'état dans lequel il se trouvait déjà. IDLE veut dire en ligne, pas en émission.",
+      "Antenna Genius : une option pour inscrire l'antenne SÉLECTIONNÉE dans MY_ANTENNA, sous le nom qu'elle porte sur le switch, avant l'antenne par défaut des conditions de trafic. C'est la prise d'antenne sur laquelle la radio émet (ANT1/ANT2 sur un Flex) qui décide du port retenu, le câblage prise→port se règlant une fois dans les préférences — aucun des deux appareils ne peut le dire. Quand le port ne peut pas être déterminé, le journal conserve l'antenne par défaut plutôt que d'en nommer une au hasard.",
+      "L'onglet des diplômes à côté de la saisie (F3) ne propose plus que les diplômes suivis par la station, et écarte ceux qui sont désactivés — la même liste que l'onglet Diplômes. Il proposait tous les diplômes existants : une station qui en chasse trois choisissait ses références dans une liste de vingt.",
+      "Les réglages CAT posent deux questions au lieu d'une : QUELLE RADIO, puis COMMENT ELLE EST RELIÉE — la seconde n'apparaissant que là où il y a un choix. OmniRig ouvre la liste, les marques suivent par ordre alphabétique, et chacune ne propose que ce qu'elle a : USB pour un Yaesu ou un Xiegu, USB ou un pont RS-232 vers Ethernet pour un Kenwood ou un Elecraft, USB ou son protocole réseau propre pour un Icom, et rien à choisir pour un FlexRadio ou un SunSDR, qui n'ont qu'une voie chacun. L'ancienne liste mélangeait les deux questions — « Icom (USB) » et « Icom (réseau) » étaient deux entrées tandis que Kenwood et Elecraft cachaient le même choix dans un champ plus bas — et l'exemple d'adresse réseau citait le port 4532, celui de Hamlib rigctld, que OpsLog propose lui-même sous « Partager le CAT ».",
+      "Une liste de satellites éditable (Préférences → Listes → Satellites). Le champ du nom de satellite dans la saisie les propose en liste déroulante, par ordre alphabétique, et accepte toujours ce qu'on tape. SAT_NAME est comparé caractère par caractère par les diplômes et par LoTW — AO-91 et AO91 sont deux satellites différents pour tout ce qui suit — donc une orthographe mémorisée vaut mieux qu'une ressaisie à chaque passage.",
+      "Diplômes, comparaison des districts RDA : la liste des divergences est plus haute et défile, un indicatif y ouvre le contact, et les boutons comparer et remplir les districts disent qu'ils travaillent. Elle était limitée à six lignes visibles environ sur deux cents, dans un panneau qui ne défilait pas pour montrer le reste, et rien n'y était actionnable.",
+      "Les préférences ne se redessinent plus au rythme de la fenêtre principale. Étant un enfant de la vue principale, tout le panneau était reconstruit à chaque spot du cluster et à chaque mise à jour CAT — plusieurs fois par seconde un soir chargé — ce qui donnait l'impression d'une page qui se rafraîchit sans arrêt et faisait rater les clics, l'élément sous le pointeur étant remplacé entre l'appui et le relâchement.",
+      "Un lancement qui échoue avant l'apparition de la fenêtre dit désormais pourquoi, à l'écran et dans un journal de démarrage tenu hors du dossier data. Toute panne survenant avant ce point était invisible — pas de fenêtre, pas de dossier, aucun fichier à lire — et les causes sont nommées : un runtime WebView2 absent ou bloqué, un « bloqueur Edge » qui empêche le moteur avec lequel OpsLog dessine son interface, un dossier où Windows refuse d'écrire, une copie déjà lancée. WebView2 reçoit aussi son propre dossier de profil sur le disque local, réessaie sans accélération GPU après un lancement bloqué, et peut utiliser un runtime en version fixe déposé à côté d'OpsLog là où l'installateur ne peut pas s'exécuter."
+    ]
+  },
   {
     "version": "0.26.13",
     "date": "",
-    "en": [],
+    "en": [
-    "fr": []
+      "Elecraft console: MOX unkeys again, and the power and SWR bars move while transmitting. The poll stops while the carrier is up — the rig refuses most questions then — and the panel was left believing the radio was still receiving, so pressing MOX a second time sent another transmit command instead of stopping.",
+      "Elecraft console: RIT and XIT can be moved — ±10 and ±100 Hz buttons with the offset shown beside them. A lit RIT button says the feature is on and nothing about where it has put the receiver.",
+      "Elecraft console: a 4.0 kHz filter button, the K3 maximum and the one FT8 wants.",
+      "FT decodes: a station that is new on both the band and the mode now shows both badges. That status had no badge of its own, so those rows passed the BAND and MODE filters and then displayed no reason for being in the list — only their grid or prefix badge, which looked like the filter leaking.",
+      "Two copies of MSHV are now told apart. MSHV calls every instance 'MSHV', and the dial frequency was filed under that name alone — so a second copy on another band overwrote the first, and decodes made on 14.095 came out labelled 2190 m. Instances are identified by their sending socket as well as their name, and a second one is shown as 'MSHV #2'."
+    ],
+    "fr": [
+      "Console Elecraft : MOX repasse bien en réception, et les barres de puissance et de ROS bougent pendant l'émission. L'interrogation s'arrête quand la porteuse est levée — la radio refuse alors la plupart des questions — et le panneau croyait donc la radio toujours en réception : un second appui sur MOX envoyait une nouvelle commande d'émission au lieu d'arrêter.",
+      "Console Elecraft : le RIT et le XIT se règlent — boutons ±10 et ±100 Hz avec le décalage affiché à côté. Un bouton RIT allumé dit que la fonction est active et rien sur l'endroit où elle a mis le récepteur.",
+      "Console Elecraft : un bouton de filtre à 4,0 kHz, le maximum du K3 et celui qu'il faut pour le FT8.",
+      "Décodes FT : une station nouvelle à la fois sur la bande et dans le mode affiche maintenant les deux badges. Ce statut n'avait pas de badge à lui : ces lignes passaient les filtres BANDE et MODE puis n'affichaient aucune raison d'être là — seulement leur badge de locator ou de préfixe, ce qui donnait l'impression d'un filtre qui fuyait.",
+      "Deux copies de MSHV sont maintenant distinguées. MSHV nomme chaque instance « MSHV », et la fréquence d'affichage était rangée sous ce seul nom : une seconde copie sur une autre bande écrasait la première, et des décodes faits sur 14.095 ressortaient étiquetés 2190 m. Les instances sont désormais identifiées par leur socket autant que par leur nom, et la seconde s'affiche « MSHV #2 »."
+    ]
   },
   {
     "version": "0.26.12",

fatalbox_other.go

@@ -0,0 +1,6 @@
+//go:build !windows
+
+package main
+
+// fatalBox is Windows-only; elsewhere the terminal carries the message.
+func fatalBox(title, text string) { println(title + ": " + text) }

fatalbox_windows.go

@@ -0,0 +1,27 @@
+//go:build windows
+
+package main
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+// fatalBox shows a message box and returns.
+//
+// A GUI-subsystem program has no console: println goes nowhere, and a launch
+// that ends before the window exists ends in complete silence. Every silent exit
+// in main now says something here first — an operator who is told "another
+// OpsLog is already running" can act on it; one who sees nothing files "it does
+// not start", which is the report nobody can answer.
+func fatalBox(title, text string) {
+	user32 := syscall.NewLazyDLL("user32.dll")
+	proc := user32.NewProc("MessageBoxW")
+	t, err1 := syscall.UTF16PtrFromString(text)
+	ti, err2 := syscall.UTF16PtrFromString(title)
+	if err1 != nil || err2 != nil {
+		return
+	}
+	const mbIconError = 0x00000010
+	proc.Call(0, uintptr(unsafe.Pointer(t)), uintptr(unsafe.Pointer(ti)), mbIconError)
+}

frontend/package.json.md5

@@ -1 +1 @@
-704fe1bf370b669665df0606fae8a69d
+f9b41e192918fa2511f68cd1b361fcd3

frontend/src/App.tsx

@@ -488,6 +488,11 @@ export default function App() {
   const { t, lang } = useI18n();
   // === Lists from settings (fallback for first paint) ===
   const [bands, setBands] = useState<string[]>(DEFAULT_BANDS);
+  // The station's satellites, for the entry form's SAT_NAME dropdown. Held HERE
+  // and not inside the panel: loadLists() already runs when Preferences close,
+  // so a list edited there reaches the field without a restart — which is what
+  // a panel reading it once at mount could not do.
+  const [satellites, setSatellites] = useState<string[]>([]);
   const [modes, setModes] = useState<string[]>(DEFAULT_MODES);
   const modesRef = useRef(modes);
   useEffect(() => { modesRef.current = modes; }, [modes]);
@@ -3081,6 +3086,7 @@ export default function App() {
       const l: ListsSettings = await GetListsSettings();
       setRstLists({ phone: (l as any).rst_phone ?? [], cw: (l as any).rst_cw ?? [], digital: (l as any).rst_digital ?? [] });
       if (l.bands && l.bands.length) setBands(l.bands);
+      setSatellites([...(((l as any).satellites ?? []) as string[])].filter(Boolean).sort());
       if (l.modes && l.modes.length) {
         setModePresets(l.modes);
         const names = l.modes.map((m) => m.name);
@@ -4188,6 +4194,41 @@ export default function App() {
     setLookupResult(null);
   }
 
+  // The Settings dialog is memoised (see SettingsModal), which only helps while
+  // its props hold still. These three would otherwise be new functions on every
+  // App render — several times a second with a cluster running — and the memo
+  // would compare unequal every time and re-render the whole panel anyway.
+  const openEditRef = useRef<(id: number) => void>(() => {});
+  // Refreshed on every render, read only when Settings opens: the dialog gets a
+  // callback whose identity never changes, and still calls the current one.
+  useEffect(() => { openEditRef.current = (id: number) => { void openEdit(id); }; });
+  // The stable wrapper the dialog actually receives.
+  const openQSOFromSettings = useCallback((id: number) => openEditRef.current(id), []);
+  const closeSettings = useCallback(() => {
+    setShowSettings(false);
+    setSettingsSection(undefined);
+    refreshChaseNew();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onSettingsSaved = useCallback(() => {
+    loadStation(); loadLists(); loadCATCfg(); reloadWk(); refreshManualRecReady();
+    // Drop the cached spot statuses. They are computed once per call+band+mode
+    // and never expire, so a rule change in Settings — grouping the digital
+    // modes into one slot, above all — left every spot already on screen
+    // showing the answer to the OLD question.
+    setSpotStatus({});
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onSettingsPaneChanged = useCallback((side: 'left' | 'right' | 'p3' | 'p4' | 'layout', v: string) => {
+    // Applied from the CHOSEN value, never from a re-read of the DB: the write
+    // is async and the layout must not lag a click behind.
+    if (side === 'left') setMainPaneLeft(v as MainPaneKind);
+    else if (side === 'right') setMainPaneRight(v as MainPaneKind);
+    else if (side === 'p3') setMainPane3(v as MainPaneKind);
+    else if (side === 'p4') setMainPane4(v as MainPaneKind);
+    else if (side === 'layout') setMainLayout4(v === 'cols' ? 'cols' : 'quad');
+  }, []);
+
   async function openEdit(id: number) {
     try { setEditingQSO(await GetQSO(id)); }
     catch (e: any) { setError(String(e?.message ?? e)); }
@@ -7051,6 +7092,7 @@ export default function App() {
             band={band}
             mode={mode}
             bands={bands}
+            satellites={satellites}
             onEditQso={openEdit}
             {...(!callsign.trim() && selQso ? {
               slotCall: selQso.call, slotBand: selQso.band, slotMode: selQso.mode,
@@ -8488,25 +8530,11 @@ export default function App() {
 
       {showSettings && (
         <SettingsModal
+          onEditQSO={openQSOFromSettings}
           initialSection={settingsSection}
-          onClose={() => { setShowSettings(false); setSettingsSection(undefined); refreshChaseNew(); }}
+          onClose={closeSettings}
-          onSaved={() => {
+          onSaved={onSettingsSaved}
-            loadStation(); loadLists(); loadCATCfg(); reloadWk(); refreshManualRecReady();
+          onMainPaneChanged={onSettingsPaneChanged}
-            // Drop the cached spot statuses. They are computed once per
-            // call+band+mode and never expire, so a rule change in Settings —
-            // grouping the digital modes into one slot, above all — left every
-            // spot already on screen showing the answer to the OLD question.
-            setSpotStatus({});
-          }}
-          onMainPaneChanged={(side, v) => {
-            // Applied from the CHOSEN value, never from a re-read of the DB:
-            // the write is async and the layout must not lag a click behind.
-            if (side === 'left') setMainPaneLeft(v as MainPaneKind);
-            else if (side === 'right') setMainPaneRight(v as MainPaneKind);
-            else if (side === 'p3') setMainPane3(v as MainPaneKind);
-            else if (side === 'p4') setMainPane4(v as MainPaneKind);
-            else if (side === 'layout') setMainLayout4(v === 'cols' ? 'cols' : 'quad');
-          }}
           flexAvailable={catState.backend === 'flex'}
           icomAvailable={catState.backend === 'icom'}
           yaesuAvailable={catState.backend === 'yaesu'}

frontend/src/components/AwardRefSelector.tsx

@@ -1,13 +1,13 @@
 import { useEffect, useMemo, useState } from 'react';
 import { X, Plus, Loader2 } from 'lucide-react';
-import { SearchAwardReferences, GetAwardDefs, GetAwardReferenceMeta, AwardRefsNew } from '../../wailsjs/go/main/App';
+import { SearchAwardReferences, GetAwardDefs, GetAwardReferenceMeta, AwardRefsNew, GetTrackedAwards } from '../../wailsjs/go/main/App';
 import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { useI18n } from '@/lib/i18n';
 
 type AwardRef = { code: string; name: string; dxcc: number; group: string; subgrp: string };
-type AwardDef = { code: string; name: string; field?: string; dxcc_filter?: number[] | null; dynamic?: boolean };
+type AwardDef = { code: string; name: string; field?: string; dxcc_filter?: number[] | null; dynamic?: boolean; valid?: boolean };
 type Meta = { code: string; count: number; can_update: boolean };
 
 // Fields auto-derived from structured QSO data — their awards (DXCC/WAZ/WAS/…)
@@ -94,11 +94,16 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla
     }
   }, [value]);
 
+  // The awards the operator FOLLOWS, exactly as the Awards tab reads them.
+  // This panel used to offer every award that existed, so a station chasing
+  // three of them was picking references out of a list of twenty.
+  const [tracked, setTracked] = useState<Set<string>>(new Set());
   useEffect(() => {
-    Promise.all([GetAwardDefs(), GetAwardReferenceMeta()])
+    Promise.all([GetAwardDefs(), GetAwardReferenceMeta(), GetTrackedAwards()])
-      .then(([d, m]) => {
+      .then(([d, m, tr]) => {
         setDefs((d ?? []) as any);
         setMetas(Object.fromEntries(((m ?? []) as Meta[]).map((x) => [String(x.code).toUpperCase(), x])));
+        setTracked(new Set(((tr ?? []) as string[]).map((c) => String(c).toUpperCase())));
       })
       .catch(() => {});
   }, []);
@@ -111,6 +116,12 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla
     return defs.filter((d) => {
       // Computed awards (field = dxcc/cqz/…) are derived automatically.
       if (COMPUTED_FIELDS.has(String(d.field ?? '').toLowerCase())) return false;
+      // Switched off in the award editor: not a candidate for anything.
+      if (d.valid === false) return false;
+      // Followed awards only, when a selection has been made. An empty
+      // selection means "all of them" — the same rule the Awards tab uses, so
+      // the two lists cannot disagree about what this station chases.
+      if (tracked.size > 0 && !tracked.has(String(d.code).toUpperCase())) return false;
       const scope = d.dxcc_filter ?? [];
       if (scope.length > 0 && (!dxcc || !scope.includes(dxcc))) return false;
       // Offer the award even when its reference list isn't loaded yet: a custom
@@ -122,7 +133,7 @@ export function AwardRefSelector({ dxcc, value, onChange, fieldValues, heightCla
       return true;
     }).map((d) => ({ code: d.code, name: d.name, field: String(d.field ?? '').toLowerCase() }))
       .sort((a, b) => a.code.localeCompare(b.code));
-  }, [defs, metas, dxcc]);
+  }, [defs, metas, dxcc, tracked]);
 
   // Keep the selected award valid as the offered list changes with the call.
   useEffect(() => {

frontend/src/components/ClusterGrid.tsx

@@ -588,6 +588,44 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
     if (state) saveState(COL_STATE_KEY, state);
   }, []);
 
+  // HOLDING THE LIST STILL WHILE IT IS BEING READ.
+  //
+  // A busy evening puts a spot on the list every second or two, each landing at
+  // the top and pushing everything below it down. At the top of the list that is
+  // exactly right — it is what makes the panel live. A few rows down it makes
+  // the panel unusable: the callsign under the pointer has moved by the time the
+  // click lands, and the operator ends up chasing the row they wanted.
+  //
+  // So the grid freezes as soon as it is scrolled away from the top, and says
+  // how many spots are waiting. Scrolling back to the top releases it, as does
+  // clicking the notice. Nothing is lost — the spots keep arriving in the shared
+  // list; this only decides when the GRID is allowed to redraw with them.
+  const [held, setHeld] = useState<ClusterSpot[] | null>(null);
+  const shown = held ?? rows;
+
+  // How many arrived since the freeze. Counted by finding the frozen top row in
+  // the live list rather than by comparing lengths: the list is a ring buffer,
+  // so once it is full the length stops growing and a length comparison would
+  // report nothing new for the rest of the evening.
+  const spotID = (r: ClusterSpot) => `${(r as any).received_at}-${r.dx_call}-${(r as any).source_id}`;
+  const waiting = useMemo(() => {
+    if (!held || held.length === 0) return 0;
+    const top = spotID(held[0]);
+    const i = rows.findIndex((r) => spotID(r) === top);
+    return i < 0 ? rows.length : i; // fell out of the buffer: everything is new
+  }, [held, rows]);
+
+  const onBodyScroll = (e: { top: number }) => {
+    const down = e.top > 4; // a pixel or two of overscroll is not "scrolled down"
+    if (!down && held) setHeld(null);
+    if (down && !held) setHeld(rows);
+  };
+
+  const release = () => {
+    setHeld(null);
+    gridRef.current?.api?.ensureIndexVisible(0, 'top');
+  };
+
   function handleRowClicked(e: RowClickedEvent<ClusterSpot>) {
     if (e.data && onSpotSelect) onSpotSelect(e.data);
   }
@@ -646,7 +684,7 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
           <AgGridReact<ClusterSpot>
             ref={gridRef}
             theme={hamlogTheme}
-            rowData={rows}
+            rowData={shown}
             columnDefs={columnDefs}
             defaultColDef={defaultColDef}
             context={context}
@@ -658,11 +696,20 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Pro
             onSortChanged={saveColumnState}
             onRowClicked={handleRowClicked}
             onRowDoubleClicked={handleRowDoubleClicked}
+            onBodyScroll={onBodyScroll}
             animateRows={false}
             suppressCellFocus
             getRowId={(p) => `${(p.data as any).received_at}-${(p.data as any).dx_call}-${(p.data as any).source_id}`}
           />
         </div>
+        {/* Only when something is actually waiting: a frozen list with nothing
+            new to show needs no announcement. */}
+        {waiting > 0 && (
+          <button type="button" onClick={release}
+            className="absolute left-1/2 -translate-x-1/2 top-1 z-10 rounded-full border border-primary bg-primary px-3 py-1 text-[11px] font-semibold text-primary-foreground shadow-lg hover:opacity-90">
+            {t('clg2.newSpots', { n: waiting })}
+          </button>
+        )}
       </div>
 
       <Dialog open={pickerOpen} onOpenChange={setPickerOpen}>

frontend/src/components/DecodesPanel.tsx

@@ -316,6 +316,22 @@ const ENTITY_BADGE: Record<string, { label: string; cls: string }> = {
   'new-call': { label: 'dec.stCall', cls: 'bg-muted text-muted-foreground' },
 };
 
+// entityBadgesFor turns a status into the badges that describe it.
+//
+// A LIST, because "new-band-mode" is two facts at once — new on this band and
+// new in this mode — and the map above has an entry for neither. It was read
+// with a single lookup, which returned nothing for that status: those rows
+// passed the BAND and MODE filters and then showed no reason for being there,
+// which is precisely what was reported. catsOf has always split the status into
+// its two categories; this is the same split, on the screen.
+function entityBadgesFor(status: string): { label: string; cls: string }[] {
+	if (status === 'new-band-mode') {
+		return [ENTITY_BADGE['new-band'], ENTITY_BADGE['new-mode']];
+	}
+	const one = ENTITY_BADGE[status];
+	return one ? [one] : [];
+}
+
 // The orthogonal ones: a station already worked for its entity can still be a
 // new grid, a new prefix or a park never logged.
 //
@@ -1004,10 +1020,10 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
             {g.decodes.map((d, i) => {
               const e = statusOf(d);
               const st = e?.status && e.status !== 'worked' ? e.status : '';
-              const entity = st ? ENTITY_BADGE[st] : undefined;
+              const entities = st ? entityBadgesFor(st) : [];
               const extras = EXTRA_BADGES.filter((b) => !!e?.[b.key]);
               const mine = !!me && d.call === me;
-              const hot = !!entity || extras.length > 0;
+              const hot = entities.length > 0 || extras.length > 0;
               // Someone answering us outranks everything else on the screen.
               const replying = answersMe(d.msg);
               // The station we are calling, so it can be picked out of a slot
@@ -1096,11 +1112,11 @@ export function DecodesPanel({ decodes, txMsgs, txState, txStates, spotStatus, o
                         {t('dec.wkd')}
                       </span>
                     )}
-                    {entity && (
+                    {entities.map((b) => (
-                      <span className={cn('rounded px-1 py-px text-[10px] font-bold uppercase tracking-wide shrink-0', entity.cls)}>
+                      <span key={b.label} className={cn('rounded px-1 py-px text-[10px] font-bold uppercase tracking-wide shrink-0', b.cls)}>
-                        {t(entity.label)}
+                        {t(b.label)}
                       </span>
-                    )}
+                    ))}
                     {extras.map((b) => {
                       // A square WORKED but not yet confirmed is a different job
                       // from one never worked: a QSL to chase, not a QSO to make.

frontend/src/components/DetailsPanel.tsx

@@ -8,6 +8,7 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
+import { Combobox } from '@/components/ui/combobox';
 import { pathBetween, pathBetweenLatLon, gridToLatLon } from '@/lib/maidenhead';
 import { BandSlotGrid } from '@/components/BandSlotGrid';
 import { AwardRefSelector } from '@/components/AwardRefSelector';
@@ -70,6 +71,10 @@ interface Props {
   band: string;
   mode: string;
   bands?: string[]; // configured bands for the worked-before matrix columns
+  // The station's satellites, for the SAT_NAME dropdown. Passed in rather than
+  // read here: the list lives in Preferences, and App already reloads it when
+  // Preferences close — a panel reading it once at mount would need a restart.
+  satellites?: string[];
   // When the entry form is empty and a QSO is selected in the log grid, the
   // Stats (F1) matrix shows THAT contact's entity instead of sitting blank.
   // Only the matrix is redirected — every other tab still edits the live entry.
@@ -150,7 +155,7 @@ function Field({ label, span = 1, className, children }: { label: string; span?:
   );
 }
 
-export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
+export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth, name, country, comment, note, details, onChange, wb, wbBusy, band, mode, bands, satellites = [], slotCall, slotBand, slotMode, slotWb, slotWbBusy, tab, onTab, keyerActive, onEditQso }: Props) {
   const { t } = useI18n();
   const [internalOpen, setInternalOpen] = useState<TabName>('stats');
   const open = tab ?? internalOpen; // controlled when `tab` is provided
@@ -478,7 +483,25 @@ export function DetailsPanel({ callsign, prefix, operatorGrid, remoteGrid, qth,
           {satelliteMode && (
             <>
               <Field label={t('detp.satName')} span={3}>
-                <Input value={details.sat_name} onChange={(e) => onChange({ sat_name: e.target.value })} />
+                {/* The station's own satellites, in alphabetical order, with the
+                    box still open to anything typed: SAT_NAME is compared
+                    character for character by the awards and by LoTW, so a
+                    remembered spelling beats a fresh one every pass — but a bird
+                    worked once and never added to the list must not be
+                    impossible to log. */}
+                {/* showToggle: without the chevron this control is a text box that
+                    happens to open on a keystroke, which nobody discovers — and
+                    is exactly what "there is still no dropdown" meant.
+                    allowFreeText: the list is the station's own, so a bird
+                    worked once and never added to it must still be loggable. */}
+                <Combobox
+                  value={details.sat_name}
+                  options={satellites}
+                  placeholder={t('detp.satName')}
+                  showToggle
+                  allowFreeText
+                  onChange={(v) => onChange({ sat_name: v })}
+                />
               </Field>
               <Field label={t('detp.satelliteMode')} span={3}>
                 <Input value={details.sat_mode} onChange={(e) => onChange({ sat_mode: e.target.value })} />

frontend/src/components/ElecraftPanel.tsx

@@ -4,7 +4,7 @@ import {
   GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
   SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
   SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
-  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, NudgeKenwoodRIT,
   GetCATState,
 } from '../../wailsjs/go/main/App';
 import { cn } from '@/lib/utils';
@@ -20,7 +20,7 @@ type KenwoodState = {
   power_meter: number; swr: number; swr_raw: number;
   rf_power: number; af_gain: number; rf_gain: number; mic_gain: number; squelch: number;
   preamp: boolean; att: boolean; nb: boolean; nr: boolean; agc?: string;
-  filter_hz: number; antenna: number; rit: boolean; xit: boolean; key_speed: number;
+  filter_hz: number; antenna: number; rit: boolean; xit: boolean; rit_offset: number; key_speed: number;
   meters_provisional: boolean;
 };
 
@@ -29,14 +29,17 @@ const ZERO: KenwoodState = {
   s_meter: 0, s_meter_raw: 0, power_meter: 0, swr: 0, swr_raw: 0,
   rf_power: 0, af_gain: 0, rf_gain: 0, mic_gain: 0, squelch: 0,
   preamp: false, att: false, nb: false, nr: false,
-  filter_hz: 0, antenna: 0, rit: false, xit: false, key_speed: 0,
+  filter_hz: 0, antenna: 0, rit: false, xit: false, rit_offset: 0, key_speed: 0,
   meters_provisional: true,
 };
 
 // Filter widths worth a button. CW work happens at 200-500 Hz, SSB at 2.4-2.8
 // kHz; the rest of the range is reachable from the radio's own knob, and a
 // panel offering thirty widths is slower to use than the knob it replaces.
-const FILTERS = [200, 400, 700, 1000, 1800, 2400, 2800];
+// 4.0k is the K3 maximum and the one FT8 wants: a 2.8 kHz filter clips the
+// top of the FT8 sub-band, and the decodes that go missing are the ones
+// nobody notices are missing.
+const FILTERS = [200, 400, 700, 1000, 1800, 2400, 2800, 4000];
 
 // Raw S-meter → S units. The K3 answers 0-21 across S0…S9+60; S9 is taken at
 // raw 9 and each step above it as 6 dB. PROVISIONAL, like the rest of the
@@ -281,6 +284,15 @@ export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) =>
         <div className="flex flex-wrap items-center gap-1.5">
           <Toggle label="RIT" on={view.rit} off={off} onClick={() => SetKenwoodRIT(!view.rit).catch(setErrMsg)} />
           <Toggle label="XIT" on={view.xit} off={off} onClick={() => SetKenwoodXIT(!view.xit).catch(setErrMsg)} />
+          {/* The offset itself. A lit RIT button says the feature is on and
+              nothing about where it has put the receiver. */}
+          {[-100, -10, 10, 100].map((d) => (
+            <Toggle key={d} label={(d > 0 ? '+' : '') + d} on={false} off={off}
+              onClick={() => NudgeKenwoodRIT(d).catch(setErrMsg)} />
+          ))}
+          <span className="text-[11px] font-mono tabular-nums text-muted-foreground w-16">
+            {view.rit_offset > 0 ? '+' : ''}{view.rit_offset || 0} Hz
+          </span>
           <Toggle label={t('k3.clear')} on={false} off={off} onClick={() => ClearKenwoodRIT().catch(setErrMsg)} />
           {/* Antenna only when the radio answered AN — a K3 without the internal
               ATU has one socket and no switch to offer. */}

frontend/src/components/FlexPanel.tsx

@@ -725,7 +725,7 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                       const next = { ...rstChase, offset_hz: v };
                       setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
                     }}
-                    className="w-12 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono" />
+                    className="w-16 h-6 rounded border border-input bg-background px-1.5 text-[11px] font-mono" />
                   Hz
                 </label>
               )}

frontend/src/components/SettingsModal.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { memo, useEffect, useMemo, useRef, useState } from 'react';
 import {
   ArrowDown, ArrowUp, ArrowLeft, ArrowRight, Copy, Plus, Star, StarOff, Trash2,
   ChevronDown, ChevronRight,
@@ -13,7 +13,7 @@ import {
   ListProfiles, GetActiveProfile, SaveProfile, DeleteProfile, ActivateProfile, DuplicateProfile,
   GetRotators, SaveRotators, TestRotatorDevice, RotatorPark, RotatorStop,
   GetRotorPresets, SaveRotorPresets, ResetRotorPresets,
-  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase, CheckHamlogKey, CompareRDASources,
+  GetUltrabeamSettings, SaveUltrabeamSettings, TestUltrabeam, CompactDatabase, CheckHamlogKey, CompareRDASources, ApplyRDAChoices,
   GetAntGeniusSettings, SaveAntGeniusSettings,
   GetTunerGeniusSettings, SaveTunerGeniusSettings,
   GetPSUSettings, SavePSUSettings,
@@ -58,7 +58,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax, StartTCIAudio, StopTCIAudio, GetTCIAudioStatus, RecordTCIAudio, GetTCIRecordAudio, SetTCIRecordAudio,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax, 
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -175,6 +175,11 @@ interface Props {
   flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
   icomAvailable?: boolean; // CAT backend is Icom → offer the Icom console as a Main pane
   yaesuAvailable?: boolean; // CAT backend is Yaesu → offer the Yaesu console as a Main pane
+  // Opens a QSO in the editor. Settings is not where a log is edited — but the
+  // RDA comparison lists contacts whose district is in dispute, and a list of
+  // things to fix that cannot be acted on is a list to write down and look up
+  // again later.
+  onEditQSO?: (id: number) => void;
 }
 
 // Pretty little card showing what OpsLog will stamp on each QSO based on
@@ -200,6 +205,7 @@ type SectionId =
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
+  | 'lists-satellites'
   | 'cluster'
   | 'backup'
   | 'database'
@@ -310,6 +316,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'group', label: t('nav.lists'), icon: Database, defaultOpen: true, children: [
         { kind: 'item', label: t('sec.bands'),      id: 'lists-bands' },
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
+        { kind: 'item', label: t('sec.satellites'), id: 'lists-satellites' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
@@ -339,7 +346,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 // Map section id → i18n key (breadcrumb / placeholders).
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
-  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
+  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes', 'lists-satellites': 'sec.satellites',
   cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
@@ -361,6 +368,7 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
   lookup: 'Callsign Lookup',
   'lists-bands': 'Bands',
   'lists-modes': 'Modes & default RST',
+  'lists-satellites': 'Satellites',
   cluster: 'DX Cluster',
   backup: 'Database backup',
   database: 'Database',
@@ -1476,7 +1484,59 @@ const ICOM_MODELS: { name: string; addr: number }[] = [
   { name: 'IC-9700', addr: 0xA2 },
 ];
 
-export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable }: Props) {
+// The radios OpsLog talks to, by BRAND, and the ways each one can be reached.
+//
+// Three connections exist in the world and each brand has its own subset:
+//   usb    — a COM port, the radio's own USB or a serial cable
+//   bridge — RS-232 carried over Ethernet by a serial bridge (ser2net, an
+//            Ethernet-serial box): the SAME CAT bytes, a socket instead of wire
+//   native — the manufacturer's own network protocol, a session of its own
+//
+// The backend NAME stored in settings is unchanged — 'icom-net' is still
+// 'icom-net' — because a settings file written by an older build has to keep
+// working. This table is only how the two questions map onto it.
+// OmniRig leads — it is the one that works with any radio, so it is where
+// someone who does not find their rig below should land. The rest are
+// alphabetical, because a list of brands has no other defensible order.
+const CAT_BRANDS: { id: string; label: string; links: string[]; backend: (link: string) => string }[] = [
+  { id: 'omnirig', label: 'OmniRig (any rig)', links: ['usb'], backend: () => 'omnirig' },
+  { id: 'elecraft', label: 'Elecraft K3 / K4', links: ['usb', 'bridge'], backend: () => 'elecraft' },
+  { id: 'tci', label: 'Expert Electronics / SunSDR (TCI)', links: ['native'], backend: () => 'tci' },
+  { id: 'flex', label: 'FlexRadio (SmartSDR)', links: ['native'], backend: () => 'flex' },
+  { id: 'icom', label: 'Icom', links: ['usb', 'native'], backend: (l) => (l === 'native' ? 'icom-net' : 'icom') },
+  { id: 'kenwood', label: 'Kenwood', links: ['usb', 'bridge'], backend: () => 'kenwood' },
+  { id: 'xiegu', label: 'Xiegu', links: ['usb'], backend: () => 'xiegu' },
+  { id: 'yaesu', label: 'Yaesu', links: ['usb'], backend: () => 'yaesu' },
+];
+
+// brandOfBackend reads the stored backend back into the two questions.
+function brandOfBackend(backend: string, kenwoodLink?: string): { brand: string; link: string } {
+  switch (backend) {
+    case 'icom-net': return { brand: 'icom', link: 'native' };
+    case 'icom': return { brand: 'icom', link: 'usb' };
+    case 'flex': return { brand: 'flex', link: 'native' };
+    case 'tci': return { brand: 'tci', link: 'native' };
+    case 'yaesu': return { brand: 'yaesu', link: 'usb' };
+    case 'xiegu': return { brand: 'xiegu', link: 'usb' };
+    case 'kenwood': case 'elecraft':
+      return { brand: backend, link: kenwoodLink || 'usb' };
+    default: return { brand: 'omnirig', link: 'usb' };
+  }
+}
+
+// SETTINGS DOES NOT RE-RENDER WITH THE MAIN WINDOW.
+//
+// It is a child of App, and App re-renders on every cluster spot, every CAT
+// status push, every decode — several times a second on a busy evening. Each of
+// those re-rendered this entire panel, which is large enough that the rebuild
+// takes longer than the gap between them: the page looked like it was
+// refreshing ten times a second and buttons stopped responding, because the
+// element under the pointer was replaced between the press and the release.
+//
+// memo() cuts that off. It only works if the props hold still, which is why
+// App passes callbacks that do not change identity on every render — see the
+// useCallback wrappers there.
+function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable, onEditQSO }: Props) {
   const { t } = useI18n();
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
@@ -1505,7 +1565,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [activeProfile, setActiveProfile] = useState<Profile | null>(null);
   const updateActive = (patch: Partial<Profile>) =>
     setActiveProfile((p) => (p ? { ...p, ...patch } : p));
-  const [lists, setLists] = useState<ListsSettings>({ bands: [], modes: [], rst_phone: [], rst_cw: [], rst_digital: [] });
+  const [lists, setLists] = useState<ListsSettings>({ bands: [], modes: [], rst_phone: [], rst_cw: [], rst_digital: [], satellites: [] });
   // RST report lists edited as free text (one/space-separated values).
   const [rstText, setRstText] = useState({ phone: '', cw: '', digital: '' });
   // Custom band drafts (catalog covers ADIF spec but the user may have
@@ -1514,12 +1574,31 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120, flex_dvk_dax: false,
-    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
+    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_link: 'usb', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0, offset_on: false, offset_hz: 0,
     digital_default: 'FT8', share_enabled: false, share_port: 4532, share_proto: 'rigctl', share_tci_port: 40001,
     ptt_hotkey_enabled: false, ptt_hotkey: '', ptt_hotkey_toggle: false,
   });
+  // Brand + connection, derived from the stored backend rather than held
+  // separately: two sources for one fact drift apart the first time something
+  // else writes the backend (loading a profile, an older settings file).
+  const catBrand = brandOfBackend(catCfg.backend, (catCfg as any).kenwood_link).brand;
+  const catLink = brandOfBackend(catCfg.backend, (catCfg as any).kenwood_link).link;
+  const applyCatBrand = (id: string) => {
+    const b = CAT_BRANDS.find((x) => x.id === id);
+    if (!b) return;
+    // Keep the connection when the new brand offers it, otherwise take its
+    // first — picking Flex from Kenwood-over-USB has to land on something.
+    const link = b.links.includes(catLink) ? catLink : b.links[0];
+    setCatCfg((s) => ({ ...s, backend: b.backend(link), kenwood_link: link } as any));
+  };
+  const applyCatLink = (link: string) => {
+    const b = CAT_BRANDS.find((x) => x.id === catBrand);
+    if (!b || !b.links.includes(link)) return;
+    setCatCfg((s) => ({ ...s, backend: b.backend(link), kenwood_link: link } as any));
+  };
+
   // While true, the next key press is captured as the PTT hotkey.
   const [capturingPtt, setCapturingPtt] = useState(false);
   const [rotors, setRotors] = useState<RotatorDevice[]>([]);
@@ -1543,7 +1622,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Antenna Genius (4O3A) switch settings — TCP port is fixed at 9007.
-  const [antgenius, setAntgenius] = useState<{ enabled: boolean; host: string; password: string }>({ enabled: false, host: '', password: '' });
+  const [antgenius, setAntgenius] = useState<{ enabled: boolean; host: string; password: string; use_for_my_antenna?: boolean; ant1_port?: number }>({ enabled: false, host: '', password: '', use_for_my_antenna: false, ant1_port: 1 });
   const [tunergenius, setTunergenius] = useState<{ enabled: boolean; host: string; password: string }>({ enabled: false, host: '', password: '' });
   const [psuCfg, setPsuCfg] = useState<{ enabled: boolean; com_port: string; baud: number; address: number }>({ enabled: false, com_port: '', baud: 9600, address: 1 });
 
@@ -1860,10 +1939,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // operator's own log, and answering it must not modify that log.
   const [rdaCmp, setRdaCmp] = useState<any>(null);
   const [rdaCmpBusy, setRdaCmpBusy] = useState(false);
+  // Its own message, next to its own button.
+  //
+  // A failed comparison used to write into rdaMsg — which is rendered beside
+  // the FILL DISTRICTS button, a row above. The error appeared under a button
+  // nobody had pressed, and the one that had been pressed showed nothing at
+  // all, which reads as "the button does nothing".
+  const [rdaCmpMsg, setRdaCmpMsg] = useState<string>('');
+  // Which source the operator kept, per QSO id. By id and not by row: a second
+  // comparison rebuilds the list, and a choice that followed a row number would
+  // then be applied to somebody else's contact.
+  const [rdaPick, setRdaPick] = useState<Record<number, 'log' | 'db'>>({});
+  const [rdaApplyBusy, setRdaApplyBusy] = useState(false);
   const runRDACompare = async () => {
-    setRdaCmpBusy(true); setRdaCmp(null);
+    setRdaCmpBusy(true); setRdaCmp(null); setRdaCmpMsg('');
-    try { setRdaCmp(await CompareRDASources()); }
+    try {
-    catch (e: any) { setRdaMsg(String(e?.message ?? e)); }
+      const r: any = await CompareRDASources();
+      setRdaCmp(r);
+      // A comparison that finds nothing is a RESULT, and the most likely one on
+      // a tidy log. Without a word for it the panel looked like it had not run.
+      if (!r || (r.scanned ?? 0) === 0) setRdaCmpMsg(t('rda.cmpNoRussian'));
+      else if ((r.disagree ?? 0) === 0) setRdaCmpMsg(t('rda.cmpNoConflict'));
+    } catch (e: any) { setRdaCmpMsg(String(e?.message ?? e)); }
     finally { setRdaCmpBusy(false); }
   };
 
@@ -1946,17 +2043,10 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // TCI receive-audio test bench. Polled only while the stream is open: a panel
   // that asks the backend twice a second for a stream nobody started is work
   // done for nothing.
-  const [tciAudio, setTciAudio] = useState<any>({ running: false, sample_rate: 0, frames: 0, peak_db: -99 });
+
-  const [tciRecBusy, setTciRecBusy] = useState(false);
+
+
   // Whether the QSO recorder takes its audio from the radio's own stream.
-  const [tciRec, setTciRec] = useState(false);
-  useEffect(() => { GetTCIRecordAudio().then((v: boolean) => setTciRec(!!v)).catch(() => {}); }, []);
-  const [tciRecPath, setTciRecPath] = useState('');
-  useEffect(() => {
-    if (!tciAudio.running) return;
-    const id = window.setInterval(() => { GetTCIAudioStatus().then(setTciAudio).catch(() => {}); }, 500);
-    return () => window.clearInterval(id);
-  }, [tciAudio.running]);
   const [gridStat, setGridStat] = useState<any>(null);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
@@ -1972,14 +2062,22 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       try { const n = await GetSpotTTLMinutes(); setSpotTTL(n); setSpotTTLText(String(n)); } catch { /* defaults stand */ }
       try { const n = await GetSpotMax(); setSpotMaxText(String(n)); } catch { /* defaults stand */ }
     })();
-    // Poll the feed while the panel is open: a live count is the only thing that
+  }, []);
-    // distinguishes "connected" from "connected and receiving nothing".
+  // Poll the feed only while the section that SHOWS it is open.
+  //
+  // A live count is the one thing that separates "connected" from "connected
+  // and receiving nothing", so it has to be polled — but it was polled from
+  // everywhere, re-rendering the whole dialog every three seconds whichever
+  // panel was in front. That is a heartbeat through every list and every form
+  // in Preferences for a number nobody is looking at.
+  useEffect(() => {
+    if (selected !== 'cluster') return;
     const t = window.setInterval(async () => {
       try { setPskrStatus(await GetPSKReporterStatus()); } catch { /* ignore */ }
       try { setGridStat(await GetGridCacheStatus()); } catch { /* ignore */ }
     }, 3000);
     return () => window.clearInterval(t);
-  }, []);
+  }, [selected]);
   const [selfSpot, setSelfSpot] = useState({ enabled: false, minutes: SELF_SPOT_MIN_MIN });
   const [selfSpotText, setSelfSpotText] = useState(String(SELF_SPOT_MIN_MIN));
   const [clusterStatuses, setClusterStatuses] = useState<ClusterServerStatus[]>([]);
@@ -2292,6 +2390,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         rst_phone: splitList(rstText.phone),
         rst_cw: splitList(rstText.cw),
         rst_digital: splitList(rstText.digital),
+        // Normalised HERE and not only on the field's blur: Save is reachable
+        // without ever leaving the box, and a list that depends on where the
+        // cursor went before the click is a list that sometimes saves.
+        satellites: Array.from(new Set(((lists.satellites ?? []) as string[])
+          .map((v) => v.trim().toUpperCase()).filter(Boolean))).sort(),
       } as any);
 
       if (activeProfile) {
@@ -2886,6 +2989,40 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     );
   }
 
+  function SatellitesPanel() {
+    const sats = lists.satellites ?? [];
+    return (
+      <>
+        <SectionHeader title={t('sec.satellites')} hint={t('sat.hint')} />
+        <div className="space-y-3 max-w-xl">
+          <div className="space-y-1">
+            <Label>{t('sat.listLabel')}</Label>
+            {/* Raw text, one per line, parsed on change — not a row-per-entry
+                editor with add and delete buttons. The list is short, edited
+                twice a year, and usually arrives pasted from a satellite
+                tracker; a textarea takes that paste in one gesture. */}
+            <textarea
+              className="w-full h-56 rounded-md border border-input bg-background p-2 font-mono text-xs"
+              value={sats.join('\n')}
+              placeholder={'AO-7\nAO-91\nRS-44\nSO-50'}
+              onChange={(e) => {
+                const next = e.target.value.split('\n').map((v) => v.trim());
+                setLists((s) => ({ ...s, satellites: next }));
+              }}
+              onBlur={() => setLists((s) => ({
+                // Tidied when the field is LEFT, never while typing: dropping an
+                // empty line as it is typed makes the Enter key look broken.
+                ...s,
+                satellites: Array.from(new Set((s.satellites ?? []).map((v) => v.trim().toUpperCase()).filter(Boolean))).sort(),
+              }))}
+            />
+            <p className="text-xs text-muted-foreground">{t('sat.listHint')}</p>
+          </div>
+        </div>
+      </>
+    );
+  }
+
   function ModesPanel() {
     const selected = lists.modes ?? [];
     const selectedSet = new Set(selected.map((m) => (m.name ?? '').toUpperCase()));
@@ -3033,24 +3170,40 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             {t('cat.enable')}
           </label>
 
-          <div className="grid grid-cols-2 gap-3">
+          {/* BRAND, then CONNECTION.
+              The backend list mixed the two: "Icom (USB)" and "Icom (network)"
+              were separate entries, while Kenwood and Elecraft hid the same
+              choice in a field further down. An operator picks a radio, then
+              says how it is plugged in — so that is what the panel asks, in
+              that order, and the two answers together choose the backend. */}
+          <div className="grid grid-cols-2 gap-3 items-start">
             <div className="space-y-1">
-              <Label>{t('cat.backend')}</Label>
+              <Label>{t('cat.brand')}</Label>
-              <Select value={catCfg.backend} onValueChange={(v) => setCatCfg((s) => ({ ...s, backend: v }))}>
+              <Select value={catBrand} onValueChange={(v) => applyCatBrand(v)}>
                 <SelectTrigger><SelectValue /></SelectTrigger>
                 <SelectContent>
-                  <SelectItem value="omnirig">{t('cat.optOmnirig')}</SelectItem>
+                  {CAT_BRANDS.map((b) => <SelectItem key={b.id} value={b.id}>{b.label}</SelectItem>)}
-                  <SelectItem value="flex">{t('cat.optFlex')}</SelectItem>
-                  <SelectItem value="yaesu">{t('cat.optYaesu')}</SelectItem>
-                  <SelectItem value="kenwood">{t('cat.optKenwood')}</SelectItem>
-                  <SelectItem value="elecraft">{t('cat.optElecraft')}</SelectItem>
-                  <SelectItem value="xiegu">{t('cat.optXiegu')}</SelectItem>
-                  <SelectItem value="icom">{t('cat.optIcom')}</SelectItem>
-                  <SelectItem value="icom-net">{t('cat.optIcomNet')}</SelectItem>
-                  <SelectItem value="tci">{t('cat.optTci')}</SelectItem>
                 </SelectContent>
               </Select>
             </div>
+            {/* Only where there IS a choice. A dropdown showing one entry that
+                cannot be changed is a control pretending to be a decision — a
+                Yaesu is reached over USB and that is the end of it. */}
+            {(CAT_BRANDS.find((b) => b.id === catBrand)?.links ?? []).length > 1 ? (
+              <div className="space-y-1">
+                <Label>{t('cat.kwLink')}</Label>
+                <Select value={catLink} onValueChange={applyCatLink}>
+                  <SelectTrigger><SelectValue /></SelectTrigger>
+                  <SelectContent>
+                    {(CAT_BRANDS.find((b) => b.id === catBrand)?.links ?? []).map((l) => (
+                      <SelectItem key={l} value={l}>
+                        {l === 'usb' ? t('cat.kwLinkUsb') : l === 'bridge' ? t('cat.kwLinkBridge') : t('cat.kwLinkNative')}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+            ) : <div />}
             {catCfg.backend === 'omnirig' && (
             <div className="space-y-1">
               <Label>{t('cat.omnirigRig')}</Label>
@@ -3177,7 +3330,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </Select>
                 <span className="text-xs text-muted-foreground">{t('cat.yaesuBaudHint')}</span>
               </div>
-              <div className="space-y-1">
+              <div className="col-span-2 space-y-1">
                 <label className="flex items-center gap-2 text-xs cursor-pointer">
                   <Checkbox checked={!!catCfg.yaesu_low_lines} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, yaesu_low_lines: !!c }))} />
                   {t('cat.lowerLines')}
@@ -3186,8 +3339,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
               </div>
             </>
             )}
-            {['icom', 'xiegu', 'kenwood'].includes(catCfg.backend) && (
+            {['icom', 'xiegu', 'kenwood', 'elecraft'].includes(catCfg.backend) && (
-              <div className="border-t border-border/60 pt-3">
+              <div className="col-span-2 border-t border-border/60 pt-3">
                 <label className="flex items-center gap-2 text-sm cursor-pointer">
                   <Checkbox checked={civTrace} onCheckedChange={(c) => { setCivTrace(!!c); SetCIVTrace(!!c); }} />
                   {t('cat.civTrace')}
@@ -3195,6 +3348,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             )}
             {(catCfg.backend === 'kenwood' || catCfg.backend === 'elecraft') && (
             <>
+              {/* USB or network, as a choice.
+                  The two were offered side by side with nothing to say which one
+                  the backend would use — it prefers the network address whenever
+                  the field is not empty, which is invisible from here. */}
+              {(((catCfg as any).kenwood_link || 'usb') === 'usb') && (<>
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodPort')}</Label>
                 <div className="flex gap-2">
@@ -3216,14 +3374,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     {[4800, 9600, 19200, 38400, 57600, 115200].map((r) => <SelectItem key={r} value={String(r)}>{r}</SelectItem>)}
                   </SelectContent>
                 </Select>              </div>
+              </>)}
+              {((catCfg as any).kenwood_link === 'bridge') && (
               <div className="space-y-1">
                 <Label>{t('cat.kenwoodHost')}</Label>
                 <Input
                   value={catCfg.kenwood_host || ''}
-                  placeholder="192.168.1.50:4532"
+                  placeholder="192.168.1.50:4999"
                   onChange={(e) => setCatCfg((s) => ({ ...s, kenwood_host: e.target.value }))}
-                />              </div>
+                />
-              <div className="space-y-1">
+                <p className="text-xs text-muted-foreground">{t('cat.kenwoodHostHint')}</p>
+              </div>
+              )}
+              <div className="col-span-2 space-y-1">
                 <label className="flex items-center gap-2 text-xs cursor-pointer">
                   <Checkbox checked={!!catCfg.kenwood_low_lines} onCheckedChange={(c) => setCatCfg((s) => ({ ...s, kenwood_low_lines: !!c }))} />
                   {t('cat.lowerLines')}
@@ -3836,6 +3999,38 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             />
             <p className="text-xs text-muted-foreground">{t('ag2.passwordHint')}</p>
           </div>
+
+          {/* MY_ANTENNA from the switch.
+              The working conditions hold what was PLANNED for the band; the
+              switch knows what is connected. Off by default: a station that
+              names its antennas differently in the two places would otherwise
+              find its log quietly rewritten. */}
+          <div className="border-t border-border/60 pt-3 space-y-2">
+            <label className="flex items-start gap-2 text-sm cursor-pointer">
+              <Checkbox className="mt-0.5" checked={!!antgenius.use_for_my_antenna}
+                onCheckedChange={(c) => setAntgenius((s: any) => ({ ...s, use_for_my_antenna: !!c }))} />
+              <span>
+                {t('ag2.useForMyAnt')}
+                <span className="block text-xs text-muted-foreground">{t('ag2.useForMyAntHint')}</span>
+              </span>
+            </label>
+            {!!antgenius.use_for_my_antenna && (
+              <div className="pl-6 space-y-1">
+                <Label>{t('ag2.ant1Port')}</Label>
+                <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                  {[1, 2].map((n) => (
+                    <button key={n} type="button"
+                      onClick={() => setAntgenius((s: any) => ({ ...s, ant1_port: n }))}
+                      className={cn('px-3 py-1.5 font-medium',
+                        (antgenius.ant1_port ?? 1) === n ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                      {n === 1 ? t('ag2.portA') : t('ag2.portB')}
+                    </button>
+                  ))}
+                </div>
+                <p className="text-xs text-muted-foreground">{t('ag2.ant1PortHint')}</p>
+              </div>
+            )}
+          </div>
         </div>
       </>
     );
@@ -4932,11 +5127,18 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     maxLength={24}
                     onChange={(e) => setMacro(i, { label: e.target.value })}
                   />
+                  {/* 500, not 120. A DXSpider filter is a list of prefixes and
+                      an operator's own list of wanted countries runs past a
+                      hundred characters easily — the field simply stopped
+                      accepting keystrokes, with nothing to say why, and the
+                      command was saved truncated. The title shows the whole
+                      thing, since the box cannot. */}
                   <Input
                     className="h-8 flex-1 min-w-0 font-mono text-xs"
                     placeholder={t('clu.macroCmd')}
                     value={m.cmd}
-                    maxLength={120}
+                    title={m.cmd}
+                    maxLength={500}
                     onChange={(e) => setMacro(i, { cmd: e.target.value })}
                   />
                 </div>
@@ -6557,61 +6759,11 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <strong>{t('aud.toRadioShort')}</strong> {t('aud.explainTo')}
           </p>
 
-          {/* TCI receive audio — EXPERIMENTAL, and the panel says so.
+          {/* The radio is one of the devices above when it can carry its own
-              A SunSDR already carries its receive audio on the WebSocket that
+              audio — see ListAudioInputDevices. What used to be here was a test
-              carries its commands, so none of the devices above need to exist
+              bench: open the stream, record ten seconds, key a tone. It settled
-              for it: no virtual cable, no second sound card. This is the test
+              how TCI works and has no business in front of an operator now that
-              bench for that path — it opens the stream and reports what really
+              choosing the device is the whole of the setup. */}
-              arrives, because "the stream is open" and "audio is arriving" are
-              different claims and only the second one is worth anything. */}
-          <div className="rounded-md border border-border p-3 space-y-2">
-            <div className="text-xs font-medium">{t('aud.tciTitle')}</div>
-            <div className="flex items-center gap-3 flex-wrap">
-              <Button variant={tciAudio.running ? 'default' : 'outline'} size="sm" className="h-8"
-                onClick={() => {
-                  const p = tciAudio.running ? StopTCIAudio() : StartTCIAudio(0, 48000);
-                  p.then(() => GetTCIAudioStatus().then(setTciAudio))
-                   .catch((e: any) => setTciAudio((s: any) => ({ ...s, last_err: String(e?.message ?? e) })));
-                }}>
-                {tciAudio.running ? t('aud.tciStop') : t('aud.tciStart')}
-              </Button>
-              {tciAudio.running && (
-                <span className="text-[11px] font-mono text-muted-foreground">
-                  {tciAudio.sample_rate || 0} Hz · {tciAudio.frames || 0} frames ·{' '}
-                  {tciAudio.peak_db > -90 ? tciAudio.peak_db.toFixed(1) + ' dBFS' : t('aud.tciSilent')}
-                </span>
-              )}
-            </div>
-            {/* The test that actually settles it. Frames arriving proves a
-                socket is delivering bytes; it says nothing about whether those
-                bytes are the receiver's audio, at the right rate, in the right
-                order. A file the operator can PLAY says all three at once. */}
-            {tciAudio.running && (
-              <div className="flex items-center gap-3 flex-wrap">
-                <Button variant="outline" size="sm" className="h-8" disabled={tciRecBusy}
-                  onClick={() => {
-                    setTciRecBusy(true); setTciRecPath('');
-                    RecordTCIAudio(10)
-                      .then((p: string) => setTciRecPath(p))
-                      .catch((e: any) => setTciAudio((s: any) => ({ ...s, last_err: String(e?.message ?? e) })))
-                      .finally(() => setTciRecBusy(false));
-                  }}>
-                  {tciRecBusy ? t('aud.tciRecBusy') : t('aud.tciRec')}
-                </Button>
-                {!!tciRecPath && <span className="text-[11px] font-mono text-muted-foreground truncate">{tciRecPath}</span>}
-              </div>
-            )}
-            {!!tciAudio.last_err && <p className="text-[11px] text-danger">{tciAudio.last_err}</p>}
-            <label className="flex items-start gap-2 text-xs cursor-pointer">
-              <Checkbox className="mt-0.5" checked={tciRec}
-                onCheckedChange={(c) => { setTciRec(!!c); SetTCIRecordAudio(!!c).catch(() => {}); }} />
-              <span>
-                {t('aud.tciRecord')}
-                <span className="block text-muted-foreground">{t('aud.tciRecordHint')}</span>
-              </span>
-            </label>
-            <p className="text-[11px] text-muted-foreground">{t('aud.tciHint')}</p>
-          </div>
           <div className="flex items-center gap-3">
             <Button
               variant={monitorOn ? 'default' : 'outline'}
@@ -7320,7 +7472,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="flex items-center gap-3">
             <Button size="sm" variant="secondary" onClick={runRDABackfill} disabled={rdaBusy}>
               {rdaBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
-              {t('rda.backfillRun')}
+              {rdaBusy ? t('rda.backfillRunning') : t('rda.backfillRun')}
             </Button>
             {rdaMsg && <span className="text-xs text-muted-foreground">{rdaMsg}</span>}
           </div>
@@ -7334,8 +7486,9 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           <div className="flex items-center gap-3">
             <Button size="sm" variant="secondary" onClick={runRDACompare} disabled={rdaCmpBusy}>
               {rdaCmpBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
-              {t('rda.cmpRun')}
+              {rdaCmpBusy ? t('rda.cmpRunning') : t('rda.cmpRun')}
             </Button>
+            {!!rdaCmpMsg && <span className="text-xs text-muted-foreground">{rdaCmpMsg}</span>}
             {rdaCmp && (
               <span className="text-xs text-muted-foreground">
                 {t('rda.cmpDone', {
@@ -7348,7 +7501,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           {/* The disagreements themselves. A count alone would say "there is a
               problem" and leave the operator with no way to look at it. */}
           {rdaCmp?.conflicts?.length > 0 && (
-            <div className="max-h-56 overflow-auto rounded border border-border">
+            <>
+            <p className="text-[11px] text-muted-foreground">
+              {t('rda.cmpListHint', { n: rdaCmp.conflicts.length, d: rdaCmp.disagree ?? 0 })}
+            </p>
+            {/* Tall enough to work through. It was capped at 224 px — about six
+                rows of a list that can hold two hundred — inside a panel that
+                does not scroll to reveal what the box could not show. */}
+            {/* NO overscroll-contain here. It stops the wheel from chaining to
+                the settings pane behind, so with a short list — nothing to
+                scroll inside the box — the pointer over the table froze the
+                whole panel. The box scrolls when it has to; the page scrolls
+                the rest of the time. */}
+            <div className="max-h-[28rem] overflow-y-auto rounded border border-border">
               <table className="w-full text-[11px]">
                 <thead className="sticky top-0 bg-card text-left text-muted-foreground border-b border-border">
                   <tr>
@@ -7357,23 +7522,126 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                     <th className="py-1 pr-2 font-medium">{t('rda.cmpFromLog')}</th>
                     <th className="py-1 pr-2 font-medium">{t('rda.cmpFromDb')}</th>
                     <th className="py-1 pr-2 font-medium">{t('rda.cmpKind')}</th>
+                    <th className="py-1 pr-2 font-medium text-center">{t('rda.cmpKeep')}</th>
                   </tr>
                 </thead>
                 <tbody>
                   {rdaCmp.conflicts.map((c: any) => (
                     <tr key={c.qso_id} className="border-b border-border/30">
-                      <td className="py-1 px-2 font-mono font-semibold">{c.callsign}</td>
+                      {/* The callsign opens the contact. A list of things to fix
+                          that cannot be acted on is a list of things to write
+                          down and look up again later. */}
+                      <td className="py-1 px-2 font-mono font-semibold">
+                        {onEditQSO ? (
+                          <button type="button"
+                            onClick={() => { onEditQSO(c.qso_id); onClose(); }}
+                            title={t('rda.cmpOpen')}
+                            className="underline decoration-dotted underline-offset-2 hover:text-primary">
+                            {c.callsign}
+                          </button>
+                        ) : c.callsign}
+                      </td>
                       <td className="py-1 pr-2 font-mono">{c.date}</td>
                       <td className="py-1 pr-2 font-mono">{c.from_log}{c.confirmed ? ' ✓' : ''}</td>
                       <td className="py-1 pr-2 font-mono">{c.from_db}</td>
                       <td className="py-1 pr-2 text-muted-foreground">
                         {c.dated ? t('rda.cmpDated') : t('rda.cmpCurrent')}
                       </td>
+                      {/* Which one wins, on the row that shows the two values.
+                          Two buttons rather than a tick box: a tick box would
+                          have to mean one of the sources silently, and an
+                          operator arbitrating between "RO-19" and "KO-05"
+                          should be picking the value they can read, not
+                          remembering what a checked box stands for. */}
+                      <td className="py-1 pr-2 whitespace-nowrap text-center">
+                        <div className="inline-flex rounded border border-border overflow-hidden">
+                          {(['log', 'db'] as const).map((side) => (
+                            <button
+                              key={side}
+                              type="button"
+                              onClick={() => setRdaPick((p) => {
+                                const next = { ...p };
+                                if (next[c.qso_id] === side) delete next[c.qso_id];
+                                else next[c.qso_id] = side;
+                                return next;
+                              })}
+                              className={`px-2 py-0.5 font-mono text-[10px] ${rdaPick[c.qso_id] === side
+                                ? 'bg-primary text-primary-foreground'
+                                : 'hover:bg-muted'}`}
+                              title={side === 'log' ? t('rda.cmpKeepLog') : t('rda.cmpKeepDb')}
+                            >
+                              {side === 'log' ? c.from_log : c.from_db}
+                            </button>
+                          ))}
+                        </div>
+                      </td>
                     </tr>
                   ))}
                 </tbody>
               </table>
             </div>
+            {/* Applying is a separate, deliberate act. Clicking through two
+                hundred rows and having each one written as it is clicked would
+                make a slip permanent before the operator had finished
+                reading. */}
+            <div className="flex items-center gap-3 flex-wrap">
+              <Button size="sm" variant="secondary" disabled={rdaApplyBusy || Object.keys(rdaPick).length === 0}
+                onClick={async () => {
+                  setRdaApplyBusy(true);
+                  try {
+                    const choices = rdaCmp.conflicts
+                      .filter((c: any) => rdaPick[c.qso_id])
+                      .map((c: any) => ({
+                        qso_id: c.qso_id,
+                        district: rdaPick[c.qso_id] === 'log' ? c.from_log : c.from_db,
+                      }));
+                    const r: any = await ApplyRDAChoices(choices);
+                    setRdaCmpMsg(r?.message || '');
+                    setRdaPick({});
+                    // The settled rows leave the list, and the counters follow.
+                    //
+                    // They used to stay, which made a working button look like a
+                    // broken one: the operator decided a hundred contacts, the
+                    // hundred rows stayed exactly as they were, and there was
+                    // nothing anywhere to say the writing had happened. Dropping
+                    // them here rather than re-running the comparison, because
+                    // that reads the whole log — seconds of silence on a remote
+                    // database, to be told what is already known.
+                    if (r?.applied > 0) {
+                      const settled = new Set(choices.map((c: any) => c.qso_id));
+                      setRdaCmp((prev: any) => prev && ({
+                        ...prev,
+                        disagree: Math.max(0, (prev.disagree ?? 0) - r.applied),
+                        agree: (prev.agree ?? 0) + r.applied,
+                        conflicts: (prev.conflicts ?? []).filter((c: any) => !settled.has(c.qso_id)),
+                      }));
+                    }
+                  } catch (e: any) {
+                    setRdaCmpMsg(String(e?.message ?? e));
+                  } finally {
+                    setRdaApplyBusy(false);
+                  }
+                }}>
+                {rdaApplyBusy ? <Loader2 className="size-3.5 animate-spin mr-1.5" /> : null}
+                {t('rda.cmpApply', { n: Object.keys(rdaPick).length })}
+              </Button>
+              <button type="button" className="text-[11px] underline decoration-dotted hover:text-primary"
+                onClick={() => setRdaPick(Object.fromEntries(rdaCmp.conflicts.map((c: any) => [c.qso_id, 'db'])))}>
+                {t('rda.cmpAllDb')}
+              </button>
+              <button type="button" className="text-[11px] underline decoration-dotted hover:text-primary"
+                onClick={() => setRdaPick(Object.fromEntries(rdaCmp.conflicts.map((c: any) => [c.qso_id, 'log'])))}>
+                {t('rda.cmpAllLog')}
+              </button>
+              {Object.keys(rdaPick).length > 0 && (
+                <button type="button" className="text-[11px] underline decoration-dotted hover:text-primary"
+                  onClick={() => setRdaPick({})}>
+                  {t('rda.cmpClear')}
+                </button>
+              )}
+            </div>
+            <p className="text-[11px] text-muted-foreground">{t('rda.cmpApplyHint')}</p>
+            </>
           )}
         </div>
       </div>
@@ -7393,6 +7661,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     lookup:         LookupPanel,
     'lists-bands':  BandsPanel,
     'lists-modes':  ModesPanel,
+    'lists-satellites': SatellitesPanel,
     cluster:        ClusterPanel,
     udp:            UDPIntegrationsPanelWrapper,
     // Module-scope components, wrapped so their props can be passed. The nested
@@ -7407,7 +7676,16 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
     uscounties:     USCountiesPanel,
     databases:      DatabasesPanel,
     autostart:      () => <AutostartPanelComponent />,
-    awards:         () => (<div className="space-y-6"><AwardsSelectionPanel profile={activeProfile ?? undefined} /><RDAPanel /></div>),
+    // RDAPanel is CALLED, not written as <RDAPanel />.
+    //
+    // It is nested inside this component, so as an element it would be a new
+    // component TYPE on every render — React cannot know it is the same panel,
+    // so it unmounts the old tree and mounts a fresh one. A fresh scroll
+    // container starts at the top, which is what threw the district comparison
+    // back to the first row every three seconds. Calling it produces the same
+    // elements in place, and the scroll position is simply never disturbed.
+    // (Safe because RDAPanel holds no hooks of its own — see PanelHost.)
+    awards:         () => (<div className="space-y-6"><AwardsSelectionPanel profile={activeProfile ?? undefined} />{RDAPanel()}</div>),
     cat:            CATPanel,
     rotator:        RotatorPanel,
     winkeyer:       WinkeyerPanel,
@@ -7575,6 +7853,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   );
 }
 
+export const SettingsModal = memo(SettingsModalImpl);
+
 // PortInput — a TCP port field you can actually clear.
 //
 // Every port box was written as `parseInt(e.target.value) || <default>`. Delete

frontend/src/components/ui/combobox.tsx

@@ -1,4 +1,5 @@
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
 import { ChevronDown } from 'lucide-react';
 import { Input } from './input';
 import { cn } from '@/lib/utils';
@@ -36,6 +37,10 @@ export function Combobox({
   // otherwise "open" onto COM7 alone.
   const [browse, setBrowse] = useState(false);
   const ref = useRef<HTMLDivElement>(null);
+  // Where the portalled menu goes. Measured from the field itself, and
+  // re-measured while it is open, so scrolling the panel underneath does not
+  // leave the list floating over the wrong row.
+  const [menuPos, setMenuPos] = useState({ top: 0, left: 0, width: 0 });
 
   useEffect(() => {
     function onDoc(e: MouseEvent) {
@@ -45,6 +50,28 @@ export function Combobox({
     return () => document.removeEventListener('mousedown', onDoc);
   }, []);
 
+  useLayoutEffect(() => {
+    if (!open) return;
+    const place = () => {
+      const el = ref.current;
+      if (!el) return;
+      const r = el.getBoundingClientRect();
+      // Opens UPWARD when there is not enough room below — which is exactly
+      // where these fields tend to sit, at the bottom of a panel.
+      const height = 240;
+      const below = window.innerHeight - r.bottom;
+      const top = below < height + 8 ? Math.max(4, r.top - height - 4) : r.bottom + 4;
+      setMenuPos({ top, left: r.left, width: r.width });
+    };
+    place();
+    window.addEventListener('scroll', place, true);
+    window.addEventListener('resize', place);
+    return () => {
+      window.removeEventListener('scroll', place, true);
+      window.removeEventListener('resize', place);
+    };
+  }, [open]);
+
   const filtered = !open ? []
     : browse ? options.slice(0, 60)
       : options.filter((o) => o.toLowerCase().includes(query.toLowerCase())).slice(0, 60);
@@ -121,8 +148,16 @@ export function Combobox({
           <ChevronDown className="size-3.5" />
         </button>
       )}
-      {open && filtered.length > 0 && (
+      {/* THE MENU IS PORTALLED to the body, and positioned from the field's own
-        <div className="absolute z-50 mt-1 max-h-60 w-full overflow-auto rounded-md border border-border bg-card shadow-lg text-xs">
+          rectangle. As an absolutely-positioned child it was clipped by whichever
+          scrolling or overflow-hidden box it happened to sit in: in the details
+          panel it was cut off after the first row, and a list showing one entry
+          of eight is worse than no list at all. */}
+      {open && filtered.length > 0 && createPortal(
+        <div
+          style={{ position: 'fixed', top: menuPos.top, left: menuPos.left, width: menuPos.width }}
+          className="z-[100] max-h-60 overflow-auto rounded-md border border-border bg-card shadow-lg text-xs"
+        >
           {filtered.map((o) => (
             <button
               key={o}
@@ -134,7 +169,8 @@ export function Combobox({
               {o}
             </button>
           ))}
-        </div>
+        </div>,
+        document.body,
       )}
     </div>
   );

frontend/src/version.ts

@@ -1,6 +1,6 @@
 // Single source of truth for the app version shown in the UI (header + About).
 // Bump this on a release (the release script updates it alongside telemetry.go).
-export const APP_VERSION = '0.26.12';
+export const APP_VERSION = '0.26.17';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

frontend/wailsjs/go/main/App.d.ts

@@ -65,6 +65,8 @@ export function ApplyAwardPreset(arg1:string,arg2:string):Promise<number>;
 
 export function ApplyAwardUpdate(arg1:string):Promise<void>;
 
+export function ApplyRDAChoices(arg1:Array<main.RDAChoice>):Promise<main.RDAApplyResult>;
+
 export function AssignAwardRefToQSOs(arg1:string,arg2:string,arg3:Array<number>):Promise<number>;
 
 export function AudioApplyLevels(arg1:number,arg2:number):Promise<void>;
@@ -575,10 +577,6 @@ export function GetStationSettings():Promise<main.StationSettings>;
 
 export function GetStationStatus():Promise<Array<main.StationDeviceStatus>>;
 
-export function GetTCIAudioStatus():Promise<cat.TCIAudioStatus>;
-
-export function GetTCIRecordAudio():Promise<boolean>;
-
 export function GetTelemetryEnabled():Promise<boolean>;
 
 export function GetTrackedAwards():Promise<Array<string>>;
@@ -807,6 +805,8 @@ export function NetSetDefaults(arg1:string,arg2:string,arg3:string,arg4:string):
 
 export function NetUpdateActive(arg1:qso.QSO):Promise<void>;
 
+export function NudgeKenwoodRIT(arg1:number):Promise<void>;
+
 export function OpenADIFFile():Promise<string>;
 
 export function OpenAwardsFolder():Promise<void>;
@@ -907,8 +907,6 @@ export function RecomputeAllAwardRefs():Promise<number>;
 
 export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
 
-export function RecordTCIAudio(arg1:number):Promise<string>;
-
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
 export function RefreshKenwood():Promise<void>;
@@ -1161,8 +1159,6 @@ export function SetSpotMax(arg1:number):Promise<void>;
 
 export function SetSpotTTLMinutes(arg1:number):Promise<void>;
 
-export function SetTCIRecordAudio(arg1:boolean):Promise<void>;
-
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
 
 export function SetUIPref(arg1:string,arg2:string):Promise<void>;
@@ -1215,14 +1211,10 @@ export function SetYaesuVOX(arg1:boolean):Promise<void>;
 
 export function StartCWDecoder():Promise<void>;
 
-export function StartTCIAudio(arg1:number,arg2:number):Promise<void>;
-
 export function StationSetRelay(arg1:string,arg2:number,arg3:boolean):Promise<void>;
 
 export function StopCWDecoder():Promise<void>;
 
-export function StopTCIAudio():Promise<void>;
-
 export function SwitchCATRig(arg1:number):Promise<void>;
 
 export function SyncFolderNow():Promise<number>;

frontend/wailsjs/go/main/App.js

@@ -70,6 +70,10 @@ export function ApplyAwardUpdate(arg1) {
   return window['go']['main']['App']['ApplyAwardUpdate'](arg1);
 }
 
+export function ApplyRDAChoices(arg1) {
+  return window['go']['main']['App']['ApplyRDAChoices'](arg1);
+}
+
 export function AssignAwardRefToQSOs(arg1, arg2, arg3) {
   return window['go']['main']['App']['AssignAwardRefToQSOs'](arg1, arg2, arg3);
 }
@@ -1090,14 +1094,6 @@ export function GetStationStatus() {
   return window['go']['main']['App']['GetStationStatus']();
 }
 
-export function GetTCIAudioStatus() {
-  return window['go']['main']['App']['GetTCIAudioStatus']();
-}
-
-export function GetTCIRecordAudio() {
-  return window['go']['main']['App']['GetTCIRecordAudio']();
-}
-
 export function GetTelemetryEnabled() {
   return window['go']['main']['App']['GetTelemetryEnabled']();
 }
@@ -1554,6 +1550,10 @@ export function NetUpdateActive(arg1) {
   return window['go']['main']['App']['NetUpdateActive'](arg1);
 }
 
+export function NudgeKenwoodRIT(arg1) {
+  return window['go']['main']['App']['NudgeKenwoodRIT'](arg1);
+}
+
 export function OpenADIFFile() {
   return window['go']['main']['App']['OpenADIFFile']();
 }
@@ -1754,10 +1754,6 @@ export function RecomputeAwardRefsForCode(arg1) {
   return window['go']['main']['App']['RecomputeAwardRefsForCode'](arg1);
 }
 
-export function RecordTCIAudio(arg1) {
-  return window['go']['main']['App']['RecordTCIAudio'](arg1);
-}
-
 export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
@@ -2262,10 +2258,6 @@ export function SetSpotTTLMinutes(arg1) {
   return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
 }
 
-export function SetTCIRecordAudio(arg1) {
-  return window['go']['main']['App']['SetTCIRecordAudio'](arg1);
-}
-
 export function SetTelemetryEnabled(arg1) {
   return window['go']['main']['App']['SetTelemetryEnabled'](arg1);
 }
@@ -2370,10 +2362,6 @@ export function StartCWDecoder() {
   return window['go']['main']['App']['StartCWDecoder']();
 }
 
-export function StartTCIAudio(arg1, arg2) {
-  return window['go']['main']['App']['StartTCIAudio'](arg1, arg2);
-}
-
 export function StationSetRelay(arg1, arg2, arg3) {
   return window['go']['main']['App']['StationSetRelay'](arg1, arg2, arg3);
 }
@@ -2382,10 +2370,6 @@ export function StopCWDecoder() {
   return window['go']['main']['App']['StopCWDecoder']();
 }
 
-export function StopTCIAudio() {
-  return window['go']['main']['App']['StopTCIAudio']();
-}
-
 export function SwitchCATRig(arg1) {
   return window['go']['main']['App']['SwitchCATRig'](arg1);
 }

frontend/wailsjs/go/models.ts

@@ -1094,6 +1094,7 @@ export namespace cat {
 	    antenna: number;
 	    rit: boolean;
 	    xit: boolean;
+	    rit_offset: number;
 	    key_speed: number;
 	    meters_provisional: boolean;
 	
@@ -1129,6 +1130,7 @@ export namespace cat {
 	        this.antenna = source["antenna"];
 	        this.rit = source["rit"];
 	        this.xit = source["xit"];
+	        this.rit_offset = source["rit_offset"];
 	        this.key_speed = source["key_speed"];
 	        this.meters_provisional = source["meters_provisional"];
 	    }
@@ -1208,28 +1210,6 @@ export namespace cat {
 	        this.fixed = source["fixed"];
 	    }
 	}
-	export class TCIAudioStatus {
-	    running: boolean;
-	    sample_rate: number;
-	    frames: number;
-	    samples: number;
-	    peak_db: number;
-	    last_err?: string;
-	
-	    static createFrom(source: any = {}) {
-	        return new TCIAudioStatus(source);
-	    }
-	
-	    constructor(source: any = {}) {
-	        if ('string' === typeof source) source = JSON.parse(source);
-	        this.running = source["running"];
-	        this.sample_rate = source["sample_rate"];
-	        this.frames = source["frames"];
-	        this.samples = source["samples"];
-	        this.peak_db = source["peak_db"];
-	        this.last_err = source["last_err"];
-	    }
-	}
 	export class YaesuTXState {
 	    available: boolean;
 	    model?: string;
@@ -1758,6 +1738,8 @@ export namespace main {
 	    enabled: boolean;
 	    host: string;
 	    password: string;
+	    use_for_my_antenna: boolean;
+	    ant1_port: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new AntGeniusSettings(source);
@@ -1768,6 +1750,8 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.host = source["host"];
 	        this.password = source["password"];
+	        this.use_for_my_antenna = source["use_for_my_antenna"];
+	        this.ant1_port = source["ant1_port"];
 	    }
 	}
 	export class AudioSettings {
@@ -2168,6 +2152,7 @@ export namespace main {
 	    yaesu_baud: number;
 	    kenwood_host: string;
 	    kenwood_port: string;
+	    kenwood_link: string;
 	    kenwood_baud: number;
 	    kenwood_data_mode: string;
 	    yaesu_low_lines: boolean;
@@ -2219,6 +2204,7 @@ export namespace main {
 	        this.yaesu_baud = source["yaesu_baud"];
 	        this.kenwood_host = source["kenwood_host"];
 	        this.kenwood_port = source["kenwood_port"];
+	        this.kenwood_link = source["kenwood_link"];
 	        this.kenwood_baud = source["kenwood_baud"];
 	        this.kenwood_data_mode = source["kenwood_data_mode"];
 	        this.yaesu_low_lines = source["yaesu_low_lines"];
@@ -2853,6 +2839,7 @@ export namespace main {
 	    rst_phone: string[];
 	    rst_cw: string[];
 	    rst_digital: string[];
+	    satellites: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new ListsSettings(source);
@@ -2865,6 +2852,7 @@ export namespace main {
 	        this.rst_phone = source["rst_phone"];
 	        this.rst_cw = source["rst_cw"];
 	        this.rst_digital = source["rst_digital"];
+	        this.satellites = source["satellites"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -3361,6 +3349,36 @@ export namespace main {
 	        this.team_last60 = source["team_last60"];
 	    }
 	}
+	export class RDAApplyResult {
+	    applied: number;
+	    failed: number;
+	    message: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new RDAApplyResult(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.applied = source["applied"];
+	        this.failed = source["failed"];
+	        this.message = source["message"];
+	    }
+	}
+	export class RDAChoice {
+	    qso_id: number;
+	    district: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new RDAChoice(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.qso_id = source["qso_id"];
+	        this.district = source["district"];
+	    }
+	}
 	export class RDAConflict {
 	    qso_id: number;
 	    callsign: string;

internal/audio/manager.go

@@ -157,7 +157,21 @@ func (m *Manager) Play(deviceID, path string, gainPct int) error {
 		// instantly, the PTT is released 120 ms later, and NOTHING says why —
 		// which is exactly what a station heard as "it plays once, then never
 		// again": the call succeeded, the sound did not.
-		if err := playPCM(deviceID, pcm, rate, ch, bits, stop); err != nil {
+		play := func() error { return playPCM(deviceID, pcm, rate, ch, bits, stop) }
+		if deviceID == NetworkDeviceID {
+			// Straight to the radio over its own link. Decided HERE rather than
+			// inside playPCM because there is no Windows endpoint to open: asked
+			// for one, the system complains about a missing device instead of
+			// saying the true thing, which is that no radio is connected.
+			fn := networkPlayer()
+			play = func() error {
+				if fn == nil {
+					return errNoNetworkRadio
+				}
+				return fn(pcm, rate, ch, bits, stop)
+			}
+		}
+		if err := play(); err != nil {
 			LogSink("audio: playback on %q failed: %v", DeviceName(deviceID), err)
 		}
 		m.mu.Lock()

internal/audio/network.go

@@ -0,0 +1,67 @@
+package audio
+
+// Playing a message through the RADIO instead of a sound card.
+//
+// A SunSDR takes its transmit audio over TCI, on the same socket as the
+// commands, so the voice keyer can hand it the message directly: no virtual
+// cable, no second sound card, no Windows mixer between the recording and the
+// air. To everything above, that radio is simply another output device.
+//
+// The device it presents itself as is a name rather than a WASAPI endpoint id,
+// which is why Play checks for it before opening anything: there is no endpoint
+// to open, and asking Windows for one produces a confusing error about a device
+// that does not exist rather than the truth, which is that nothing is connected
+// to the radio.
+
+import (
+	"errors"
+	"sync"
+)
+
+// NetworkDeviceID is the id the radio-over-network output carries in the
+// settings and in the device lists. A fixed string, not a Windows endpoint id:
+// it is chosen by us and must survive a radio being switched off and on.
+const NetworkDeviceID = "net:radio"
+
+// NetworkPlayer sends already-decoded PCM to the radio, returning when the
+// message has been played or when stop is closed.
+//
+// It carries the same arguments as the sound-card path so that Play can hand
+// over whatever it read, and the radio can decide what converting it needs —
+// the sample rate a WAV was recorded at is not the radio's business until the
+// moment it has to be resampled.
+type NetworkPlayer func(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error
+
+var (
+	netMu     sync.RWMutex
+	netPlayer NetworkPlayer
+)
+
+// SetNetworkPlayer installs (or clears, with nil) the radio's transmit path.
+//
+// Package-level rather than per-Manager: there is one radio, the CAT backend
+// owns it, and a Manager that happened to be built before the radio connected
+// would otherwise be permanently unable to reach it.
+func SetNetworkPlayer(fn NetworkPlayer) {
+	netMu.Lock()
+	netPlayer = fn
+	netMu.Unlock()
+}
+
+// networkPlayer returns the installed player, or nil.
+func networkPlayer() NetworkPlayer {
+	netMu.RLock()
+	defer netMu.RUnlock()
+	return netPlayer
+}
+
+// NetworkPlayerReady says whether a radio is currently able to take transmit
+// audio, so the settings panel can offer the option honestly rather than
+// listing a device that would fail when used.
+func NetworkPlayerReady() bool { return networkPlayer() != nil }
+
+// errNoNetworkRadio is what a message played to a radio that is not there
+// comes back with. Named, because "the device could not be opened" would send
+// an operator hunting through Windows sound settings for a device that never
+// existed.
+var errNoNetworkRadio = errors.New("no radio is connected to take the audio — check the CAT link (the radio output only works with a TCI radio)")

internal/cat/kenwood.go

@@ -91,11 +91,18 @@ type Kenwood struct {
 	keyWPM         int // CW keyer speed, for pacing the KY buffer (see kenwood_cw.go)
 	// Commands this rig answered "?;" to — asked once, then never again.
 	unsupported map[string]bool
+	// noLatch suspends that memory while a refusal is expected to be about
+	// timing rather than capability (see ask).
+	noLatch bool
 
 	// Panel state — the K3/K4 control panel, see kenwood_panel.go. Read on the
 	// same serialised link as everything else, on a slow beat for the settings
 	// and every poll for the meters.
 	panel        KenwoodTXState
+	// The icon/status word, for working out which bit says "ATU in line" — see
+	// probeIcons. Kept so only CHANGES are logged.
+	lastIcons  string
+	iconProbes int
 	panelCycle   int
 	panelLoaded  bool
 	metersLogged int
@@ -266,6 +273,15 @@ func (k *Kenwood) Connect() error {
 		// commands back produces the same). Say which of the two it is, and quote
 		// what came back, because that is the fact that decides where to look.
 		if seen := k.heard; seen != "" {
+			// Over a NETWORK link, baud means nothing and saying "check the baud
+			// rate" sends the operator to a setting that cannot be the cause.
+			// The usual mistake there is a different protocol on the other end:
+			// Hamlib's rigctld (4532) answers text, so it looks alive and never
+			// replies to ID;. OpsLog itself serves that port under "Share CAT",
+			// which makes it an easy number to reach for.
+			if k.host != "" {
+				return fmt.Errorf("kenwood: %s is sending data but no reply to ID; or IF; — got %q. That end is not speaking the radio's CAT: point this at a serial-over-network bridge or the radio's own raw CAT port, not at Hamlib rigctld (4532)", k.host, seen)
+			}
 			return fmt.Errorf("kenwood: %s is sending data but no reply to ID; or IF; — got %q. Check the baud rate (set to %d here) and that nothing else is echoing the port", k.where(), seen, k.baud)
 		}
 		if k.host != "" {
@@ -309,6 +325,15 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	if k.tx && !k.txAt.IsZero() && time.Since(k.txAt) < 30*time.Second {
 		s := k.lastState
 		s.Connected = true
+		// The panel still has to be told the radio is transmitting, and the
+		// transmit meters still have to be read — this early return used to skip
+		// both. The panel therefore showed MOX unlit while the rig was keyed, so
+		// pressing it again sent ANOTHER transmit command instead of unkeying,
+		// and the K3 stayed in TX. The power and SWR bars never moved either,
+		// for the same reason: the only moment they mean anything is the one
+		// moment they were not being read.
+		k.panel.Transmitting = true
+		k.readTXMeters()
 		return s, nil
 	}
 	raw, err := k.ask("IF;")
@@ -435,7 +460,12 @@ func (k *Kenwood) ReadState() (RigState, error) {
 	// The panel rides on the same poll and the same held mutex: its own reader
 	// would have to take turns on the serial port, and the K3 is slow enough
 	// that two readers taking turns is what makes a dial lag.
-	k.readPanel(s.Mode, s.Split, s.FreqHz)
+	// f.TX, not k.tx: the radio is the one that knows it is transmitting. k.tx
+	// only records that OPSLOG keyed it, so a carrier raised with the front-panel
+	// PTT, a footswitch or the mic button left the panel showing a receiver — and
+	// the transmit meters, which are read only while transmitting, were never
+	// read at all for anyone who keys the radio by hand.
+	k.readPanel(s.Mode, s.Split, s.FreqHz, f.TX)
 	return s, nil
 }
 
@@ -663,7 +693,12 @@ func (k *Kenwood) ask(cmd string) (string, error) {
 				// NOT "unsupported". Latching them off would blind the poll loop for
 				// good and read as "lost the rig". Only remember the OPTIONAL commands
 				// (FR/FT/…) so the poll loop stops paying a 600 ms timeout for those.
-				if want != "IF" && want != "ID" {
+				// While TRANSMITTING the rig refuses a great deal that it answers
+				// perfectly well on receive, so a "?;" then says nothing about what
+				// the radio supports. Latching it would silence a meter for the rest
+				// of the session on the strength of one badly timed question — and
+				// the meters are read precisely while transmitting.
+				if want != "IF" && want != "ID" && !k.noLatch {
 					k.unsupported[want] = true
 					debugLog.Printf("kenwood: this rig does not support %q — not asking again", cmd)
 				}

internal/cat/kenwood_panel.go

@@ -15,6 +15,10 @@ package cat
 //     good match on a bad antenna. So the raw answers are LOGGED, for a real
 //     radio to settle, and until then the panel says the scaling is provisional.
 //
+// SWR is settled: SW; answers three digits in tenths of a ratio ("SW023;" =
+// 2.3:1), from Elecraft's release note. The power meter is still read from the
+// bargraph and still provisional.
+//
 // The same discipline as the Yaesu meters, which were guessed wrong twice and
 // only settled when an FTDX10 keyed a carrier at two known power levels.
 
@@ -68,9 +72,14 @@ type KenwoodTXState struct {
 	// offer a switch that goes nowhere.
 	Antenna int `json:"antenna"`
 
-	RIT      bool `json:"rit"`
+	RIT bool `json:"rit"`
-	XIT      bool `json:"xit"`
+	XIT bool `json:"xit"`
-	KeySpeed int  `json:"key_speed"` // WPM
+	// RITOffset is the RIT/XIT offset in Hz — the number the buttons move and
+	// the one an operator is actually reading when they look at RIT at all. A
+	// lit RIT button with no offset beside it says the feature is on and
+	// nothing about where it has put the receiver.
+	RITOffset int `json:"rit_offset"`
+	KeySpeed  int `json:"key_speed"` // WPM
 
 	// MetersProvisional says the meter scaling has not been confirmed against a
 	// real radio. The panel says so rather than presenting a guess as a
@@ -97,6 +106,7 @@ type KenwoodPanelController interface {
 	SetKenwoodAntenna(int) error
 	SetKenwoodRIT(bool) error
 	SetKenwoodXIT(bool) error
+	NudgeKenwoodRIT(int) error
 	ClearKenwoodRIT() error
 	SetKenwoodTX(bool) error
 	TuneKenwoodATU() error
@@ -129,14 +139,14 @@ func (k *Kenwood) RefreshKenwood() error {
 
 // readPanel refreshes the panel. Called from ReadState with the mutex HELD, so
 // it shares the same serialised link as everything else.
-func (k *Kenwood) readPanel(mode string, split bool, txHz int64) {
+func (k *Kenwood) readPanel(mode string, split bool, txHz int64, txNow bool) {
 	k.panel.Mode = mode
 	k.panel.Split = split
 	k.panel.SplitTXHz = 0
 	if split {
 		k.panel.SplitTXHz = txHz
 	}
-	k.panel.Transmitting = k.tx
+	k.panel.Transmitting = k.tx || txNow
 	k.panel.MetersProvisional = true
 
 	if k.panel.Transmitting {
@@ -222,9 +232,16 @@ func (k *Kenwood) readPanelSettings() {
 	if v, ok := k.askNum("XT;", "XT", 1); ok {
 		k.panel.XIT = v != 0
 	}
+	// RO carries a sign, so it is read as a whole rather than through askNum.
+	if r, err := k.ask("RO;"); err == nil {
+		if hz, ok := parseKenwoodOffset(r); ok {
+			k.panel.RITOffset = hz
+		}
+	}
 	if v, ok := k.askNum("KS;", "KS", 3); ok {
 		k.panel.KeySpeed = v
 	}
+	k.probeIcons()
 }
 
 // The full-scale value of the analogue controls differs between an Elecraft and
@@ -296,27 +313,26 @@ func kenwoodAGCValue(name string) int {
 // answered and what it said, next to the power SETTING: the meter that tracks a
 // known carrier at two different power levels is the power meter, and no amount
 // of reading the reference settles that as well as one transmission does.
-var kenwoodMeterProbes = []struct {
+// SW is no longer among them: it is known, read above, and asking again during
-	cmd    string
+// a transmission costs a round trip on the one link the carrier depends on.
-	prefix string
+var kenwoodMeterProbes = []string{"SM;", "SMH;", "BG;", "PO;", "TQ;"}
-	digits int
-}{
-	{"SM;", "SM", 4},
-	{"BG;", "BG", 2},
-	{"SW;", "SW", 4},
-	{"PO;", "PO", 3},
-}
 
 // readTXMeters reads the transmit meters.
 func (k *Kenwood) readTXMeters() {
 	now := time.Now()
+	// Refusals here are about WHEN the question was asked, not about what the
+	// radio can do: a K3 says "?;" to plenty while the carrier is up.
+	k.noLatch = true
+	defer func() { k.noLatch = false }()
 	if v, ok := k.askNum("BG;", "BG", 2); ok {
 		k.panel.PowerMeter = k.powerPeak.update(kenwoodBargraphPercent(v), now)
 	}
-	if v, ok := k.askNum("SW;", "SW", 4); ok {
+	// SW; — SETTLED, from Elecraft's own release note: three digits, tenths of a
+	// ratio. "SW023;" is 2.3:1, and "SW999;" is the 99.9:1 it reports instead of
+	// infinity. This was reading FOUR digits, so every answer failed to parse
+	// and the bar stayed empty — which is why a tester saw no SWR at all.
+	if v, ok := k.askNum("SW;", "SW", 3); ok {
 		k.panel.SWRRaw = v
-		// Tenths of a ratio, provisionally: 15 → 1.5. Reported as raw as well,
-		// so the log can correct this without anyone having to trust the bar.
 		if v > 0 {
 			k.panel.SWR = float64(k.swrPeak.update(v, now)) / 10
 		}
@@ -325,12 +341,15 @@ func (k *Kenwood) readTXMeters() {
 		return
 	}
 	k.metersLogged++
+	// The RAW answers, not parsed numbers: a command that answers in a shape we
+	// did not expect is the interesting case, and a parsed "-" hides it behind
+	// the same dash as a command the radio refused.
 	raw := make([]string, 0, len(kenwoodMeterProbes))
-	for _, p := range kenwoodMeterProbes {
+	for _, cmd := range kenwoodMeterProbes {
-		if v, ok := k.askNum(p.cmd, p.prefix, p.digits); ok {
+		if r, err := k.ask(cmd); err == nil {
-			raw = append(raw, fmt.Sprintf("%s=%d", strings.TrimSuffix(p.cmd, ";"), v))
+			raw = append(raw, strings.TrimSuffix(cmd, ";")+"→"+strings.TrimSuffix(r, ";"))
 		} else {
-			raw = append(raw, strings.TrimSuffix(p.cmd, ";")+"=-")
+			raw = append(raw, strings.TrimSuffix(cmd, ";")+"→refused")
 		}
 	}
 	debugLog.Printf("kenwood: TX meters at PC=%dW: %s (compare two power settings, and a known SWR)",
@@ -396,6 +415,31 @@ func (k *Kenwood) SetKenwoodAFGain(p int) error {
 	return k.setPanel(fmt.Sprintf("AG%03d;", p*255/100))
 }
 
+// probeIcons logs the K3's icon/status word whenever it changes.
+//
+// There is no command that asks "is the ATU in line": the reference says the
+// front-panel switch functions show up as icon changes readable through IC (or
+// DS), which means the answer is a bit in a word nobody here can name yet. So
+// the word is logged when it changes, and an operator toggling the ATU while
+// watching the log hands us the bit — after which the ATU button can light up
+// honestly instead of guessing from what it last sent.
+func (k *Kenwood) probeIcons() {
+	if k.iconProbes >= 40 {
+		return
+	}
+	r, err := k.ask("IC;")
+	if err != nil {
+		k.iconProbes = 40 // this rig has no IC; stop asking
+		return
+	}
+	if r == k.lastIcons {
+		return
+	}
+	k.lastIcons = r
+	k.iconProbes++
+	debugLog.Printf("kenwood: icon status changed → %s (toggle ATU/PRE/ATT while watching this line to name the bits)", r)
+}
+
 // SetKenwoodRFGain sets the RF gain, 0-100 of the rig's own scale.
 func (k *Kenwood) SetKenwoodRFGain(p int) error {
 	return k.setPanel(fmt.Sprintf("RG%03d;", clampPercentTo(p, k.rfGainFull())))
@@ -456,6 +500,60 @@ func (k *Kenwood) SetKenwoodAntenna(n int) error {
 	return k.setPanel(fmt.Sprintf("AN%d;", n))
 }
 
+// parseKenwoodOffset reads "RO+0100;" / "RO-0250;" into Hz.
+func parseKenwoodOffset(frame string) (int, bool) {
+	body := strings.TrimSuffix(strings.TrimPrefix(frame, "RO"), ";")
+	if len(body) < 2 {
+		return 0, false
+	}
+	sign := 1
+	switch body[0] {
+	case '-':
+		sign = -1
+		body = body[1:]
+	case '+':
+		body = body[1:]
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(body))
+	if err != nil {
+		return 0, false
+	}
+	return sign * n, true
+}
+
+// NudgeKenwoodRIT moves the RIT/XIT offset by delta Hz.
+//
+// The offset is SET rather than stepped, because RO is where the radio keeps
+// it and stepping commands differ across the family. The panel's own reading is
+// the starting point, so two quick presses do not both start from the same
+// stale value.
+func (k *Kenwood) NudgeKenwoodRIT(delta int) error {
+	k.mu.Lock()
+	cur := k.panel.RITOffset
+	k.mu.Unlock()
+	next := cur + delta
+	// A pile-up is chased with a few hundred hertz of RIT; ±5 kHz is already
+	// past anything an offset is for, and past what the rig accepts.
+	if next > 5000 {
+		next = 5000
+	}
+	if next < -5000 {
+		next = -5000
+	}
+	sign := "+"
+	if next < 0 {
+		sign = "-"
+	}
+	mag := next
+	if mag < 0 {
+		mag = -mag
+	}
+	k.mu.Lock()
+	k.panel.RITOffset = next // optimistic, like the sliders
+	k.mu.Unlock()
+	return k.setPanel(fmt.Sprintf("RO%s%04d;", sign, mag))
+}
+
 func (k *Kenwood) SetKenwoodRIT(on bool) error {
 	return k.setPanel(fmt.Sprintf("RT%d;", boolDigit(on)))
 }

internal/cat/tci.go

@@ -39,6 +39,11 @@ type TCI struct {
 	// without a virtual audio cable in the way.
 	audio tciAudio
 
+	// One writer at a time. send() held the lock only long enough to READ conn,
+	// which was enough while every command came from the poll loop — a stream of
+	// audio frames from a second goroutine is not, and gorilla panics on a
+	// concurrent write rather than corrupting the socket quietly.
+	wmu        sync.Mutex // serialises writes to the socket (text AND binary)
 	mu         sync.Mutex // guards conn + writes + state
 	conn       *websocket.Conn
 	dialCancel context.CancelFunc // cancels an in-flight Connect dial (Interrupt/Stop)
@@ -61,7 +66,14 @@ type TCI struct {
 	// txAllowedKnown keeps an OLDER ExpertSDR, or a TCI-compatible program that
 	// never sends TX_ENABLE at all, from being treated as refusing: without a
 	// word from the radio we key and let it decide.
-	txAllowed      bool
+	txAllowed bool
+	// txSource is the TRX third argument: "tci" while OpsLog has audio to send,
+	// empty for the operator's microphone. See SetPTT.
+	txSource string
+	// drive is the radio's transmit drive, 0-100. Kept because a quiet
+	// transmission has two possible causes — our level or the radio's — and a
+	// log that names both settles it in one line instead of an evening.
+	drive          int
 	txAllowedKnown bool
 
 	lastSig string // last logged state signature (log only on change)
@@ -335,9 +347,49 @@ func (t *TCI) SetPTT(on bool) error {
 				"check the frequency is inside a transmit band and that TX is enabled in ExpertSDR")
 		}
 	}
+	// THE THIRD ARGUMENT NAMES THE AUDIO SOURCE, and it is the whole answer to
+	// "why does the radio ignore what I send it".
+	//
+	// TCI 2.0 §TRX: "The signal for transmitting is always taken from the
+	// microphone selected in the ExpertSDR3. If a third-party software connected
+	// via TCI wants to transmit its audio signal, you must specify the third
+	// argument - TCI." Without it the radio never sends a single chrono frame,
+	// whatever the mode and whatever is configured in its window — which is
+	// exactly what a night of experiments showed and misread as "digital modes
+	// only".
+	//
+	// Sent only when a transmission is ours to feed. A plain trx keeps the
+	// operator's own microphone, which is what every other PTT in OpsLog means.
+	t.mu.Lock()
+	src := t.txSource
+	t.mu.Unlock()
+	if on && src != "" {
+		return t.send(fmt.Sprintf("trx:0,true,%s;", src))
+	}
 	return t.send(fmt.Sprintf("trx:0,%t;", on))
 }
 
+// SetTXAudioSource says where the radio should take its transmit audio from
+// while OpsLog keys it: "tci" for the stream this program sends, "" for the
+// microphone the operator chose in ExpertSDR3.
+//
+// Set from the audio settings — it follows the "To radio" device — so keying
+// for a voice message and keying for anything else behave differently on
+// purpose: only the first one takes the audio away from the microphone.
+func (t *TCI) SetTXAudioSource(src string) {
+	t.mu.Lock()
+	changed := t.txSource != src
+	t.txSource = src
+	t.mu.Unlock()
+	if changed {
+		if src == "" {
+			debugLog.Printf("TCI: transmit audio will come from the radio's own microphone")
+		} else {
+			debugLog.Printf("TCI: transmit audio will be taken from %s when OpsLog keys the radio", src)
+		}
+	}
+}
+
 // send writes a command to the WebSocket (one writer at a time).
 func (t *TCI) send(cmd string) error {
 	t.mu.Lock()
@@ -346,6 +398,8 @@ func (t *TCI) send(cmd string) error {
 	if c == nil {
 		return fmt.Errorf("tci: not connected")
 	}
+	t.wmu.Lock()
+	defer t.wmu.Unlock()
 	_ = c.SetWriteDeadline(time.Now().Add(3 * time.Second))
 	if err := c.WriteMessage(websocket.TextMessage, []byte(cmd)); err != nil {
 		debugLog.Printf("TCI: send %q failed: %v", cmd, err)
@@ -444,7 +498,22 @@ func (t *TCI) handle(msg string) {
 		}
 	case "trx":
 		if get(0) == "0" {
+			was := t.tx
 			t.tx = get(1) == "true"
+			// Said out loud, every time. The transmit side of TCI can only be
+			// written from a log of a real transmission, and the first one came
+			// back without a single line to say whether the radio had even been
+			// keyed — which left the interesting question, why no transmit
+			// frames, indistinguishable from nobody having pressed anything.
+			if was != t.tx {
+				t.noteTXTransition(t.tx)
+			}
+		}
+	case "drive":
+		if get(0) == "0" {
+			if v, err := strconv.Atoi(get(1)); err == nil {
+				t.drive = v
+			}
 		}
 	case "tx_enable":
 		if get(0) == "0" {

internal/cat/tci_audio.go

@@ -33,6 +33,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math"
+	"strings"
 	"sync"
 	"time"
 
@@ -60,10 +61,10 @@ const tciAudioProbeMax = 40
 
 // TCIAudioStatus is what the panel polls while testing the stream.
 type TCIAudioStatus struct {
-	Running    bool   `json:"running"`
+	Running    bool  `json:"running"`
-	SampleRate int    `json:"sample_rate"`
+	SampleRate int   `json:"sample_rate"`
-	Frames     int64  `json:"frames"`  // binary frames accepted
+	Frames     int64 `json:"frames"`  // binary frames accepted
-	Samples    int64  `json:"samples"` // audio samples decoded
+	Samples    int64 `json:"samples"` // audio samples decoded
 	// PeakDB is the loudest sample of the last second, in dBFS: the one number
 	// that says "audio is really arriving" rather than "a socket is open".
 	PeakDB  float64 `json:"peak_db"`
@@ -73,19 +74,36 @@ type TCIAudioStatus struct {
 // tciAudio is the receive-side state, kept on the backend so it lives exactly
 // as long as the connection does.
 type tciAudio struct {
-	mu      sync.Mutex
+	mu          sync.Mutex
-	want    bool // the host asked for audio
+	want        bool // the host asked for audio
-	rx      int  // which receiver
+	rx          int  // which receiver
-	rate    int
+	rate        int
-	frames  int64
+	frames      int64
-	samples int64
+	samples     int64
-	peak    float64
+	peak        float64
-	peakAt  time.Time
+	peakAt      time.Time
 	probeByType map[int]int
+	// countByType counts EVERY frame per stream type, capped by nothing.
+	// The probe above stops logging after forty frames of a type; these keep
+	// counting, so a transmission that produced no transmit frames at all can
+	// be reported as a fact rather than inferred from an absence of lines.
+	countByType map[int]int64
 	lastErr     string
 	// widthLogged keeps the one-line note about the sample width to once a
 	// session — it is a fact about the radio, not an event.
 	widthLogged bool
+	// txMark is the per-type frame count when transmission began, so the census
+	// at the end reports the pass rather than the whole session.
+	txMark map[int]int64
+
+	// txFeed supplies the next frame of transmit audio when the radio asks for
+	// one, or is nil when nothing is being sent. Set under this same lock, and
+	// read on the reader goroutine — the radio's request and our answer are two
+	// halves of one exchange and must not straddle a race.
+	txFeed  func(samples int) []byte
+	txSent  int64
+	txShort int64 // requests the feed could not fill (it had run out)
+
 	// What the radio SAID about its stream at connect (audio_stream_sample_type,
 	// audio_stream_channels). Its own declaration, and it arrives before the
 	// first frame — the frame arithmetic below stays as the check on it rather
@@ -118,6 +136,13 @@ func (t *TCI) StartTCIAudio(rx, rate int) error {
 	if err := t.send(fmt.Sprintf("audio_samplerate:%d;", rate)); err != nil {
 		return err
 	}
+	// Said rather than assumed. float32 and two channels are the documented
+	// defaults and what this radio streams, but a default is a thing another
+	// program can have changed — they share the radio, not just the protocol —
+	// and a stream arriving in a format the decoder was not expecting is heard
+	// as noise, not as a mistake.
+	_ = t.send("audio_stream_sample_type:float32;")
+	_ = t.send("audio_stream_channels:2;")
 	return t.send(fmt.Sprintf("audio_start:%d;", rx))
 }
 
@@ -192,6 +217,10 @@ func (t *TCI) handleBinary(data []byte) {
 	if t.audio.probeByType == nil {
 		t.audio.probeByType = map[int]int{}
 	}
+	if t.audio.countByType == nil {
+		t.audio.countByType = map[int]int64{}
+	}
+	t.audio.countByType[stype]++
 	probe := t.audio.probeByType[stype]
 	if probe < tciAudioProbeMax {
 		t.audio.probeByType[stype]++
@@ -202,11 +231,17 @@ func (t *TCI) handleBinary(data []byte) {
 			receiver, rate, format, codec, length, stype, len(data)-tciHeaderBytes)
 	}
 
+	if stype == tciStreamTXChrono {
+		// The radio asking for the next frame of transmit audio. It is empty —
+		// the whole message IS the request — and it carries the size it wants in
+		// the header's length field, so the answer is written from what it says
+		// rather than from what we assumed.
+		t.serveChrono(rate, length)
+		return
+	}
 	if stype != tciStreamRXAudio {
-		// IQ, transmit audio, chrono. Nothing consumes them yet — but the chrono
+		// IQ and transmit audio. The latter is ours to send, not to receive:
-		// frames are what a voice keyer over TCI would have to answer, and their
+		// counted above, and dropped.
-		// size and cadence cannot be guessed from the documentation. They are
-		// logged (per type, see above) and dropped.
 		return
 	}
 	if codec != 0 {
@@ -333,3 +368,57 @@ func (t *TCI) resumeAudio() {
 // ignore the message type entirely and split every frame on ';', which would
 // have fed audio bytes to the command parser the moment a stream was opened.
 func wsMessageIsBinary(mt int) bool { return mt == websocket.BinaryMessage }
+
+// noteTXTransition reports what the stream did across a transmission.
+//
+// The voice keyer needs two numbers the documentation does not give: the size
+// and the cadence of the frames the radio expects while transmitting. They can
+// only be read off a real transmission — and the first attempt came back with a
+// log that said nothing at all, which is ambiguous: either no transmit frames
+// arrived, or they arrived and went unlogged.
+//
+// So the boundaries are marked and every stream type is counted. A pass that
+// produces "type 1: 240, and nothing else" is a RESULT — it says the radio
+// sends no chrono unless something more is asked of it — where a log with no
+// transmit lines in it was merely a silence.
+func (t *TCI) noteTXTransition(on bool) {
+	t.audio.mu.Lock()
+	if t.audio.countByType == nil {
+		t.audio.countByType = map[int]int64{}
+	}
+	if on {
+		// Let the transmit types speak again on every pass: forty frames is a
+		// budget spent long before the operator gets round to keying.
+		if t.audio.probeByType != nil {
+			delete(t.audio.probeByType, tciStreamTXAudio)
+			delete(t.audio.probeByType, tciStreamTXChrono)
+		}
+		t.audio.txMark = map[int]int64{}
+		for k, v := range t.audio.countByType {
+			t.audio.txMark[k] = v
+		}
+		streaming := t.audio.want
+		t.audio.mu.Unlock()
+		debugLog.Printf("TCI: TRANSMIT started — watching for transmit-audio (type %d) and chrono (type %d) frames; receive stream is %s",
+			tciStreamTXAudio, tciStreamTXChrono, map[bool]string{true: "open", false: "CLOSED (tick the TCI recording option, or the radio has no reason to stream)"}[streaming])
+		return
+	}
+	names := map[int]string{
+		tciStreamIQ:       "IQ",
+		tciStreamRXAudio:  "receive audio",
+		tciStreamTXAudio:  "transmit audio",
+		tciStreamTXChrono: "transmit chrono",
+	}
+	var parts []string
+	for _, k := range []int{tciStreamIQ, tciStreamRXAudio, tciStreamTXAudio, tciStreamTXChrono} {
+		if n := t.audio.countByType[k] - t.audio.txMark[k]; n > 0 {
+			parts = append(parts, fmt.Sprintf("%s (type %d): %d", names[k], k, n))
+		}
+	}
+	t.audio.mu.Unlock()
+	if len(parts) == 0 {
+		debugLog.Printf("TCI: TRANSMIT ended — NO binary frames of any type arrived during it")
+		return
+	}
+	debugLog.Printf("TCI: TRANSMIT ended — frames during the pass: %s", strings.Join(parts, ", "))
+}

internal/cat/tci_tx_play.go

@@ -0,0 +1,189 @@
+package cat
+
+// Playing a recorded message to the radio over TCI — the voice keyer's path.
+//
+// The same exchange the tone probe established, with a WAV in place of the
+// sine: the radio asks for a frame, we answer with the next slice of the
+// message, and it sets the pace. What is added here is the conversion, because
+// a recording is whatever the microphone gave it — 16-bit, often mono, often
+// not 48 kHz — and the radio wants interleaved float32 at the stream's rate.
+//
+// The message is converted ONCE, up front, rather than per frame. A voice
+// message is a few hundred kilobytes; resampling it inside the callback would
+// put arithmetic on the path that has 21 ms to answer, and a late frame is a
+// gap in what goes out.
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+	"time"
+)
+
+// tciTXFirstAskTimeout is how long to wait for the radio to ask for the first
+// frame before giving up.
+//
+// It answers within a frame or two when it is going to answer at all, so this
+// is generous. When it stays quiet the cause is always the same — the transmit
+// audio source is the microphone rather than TCI — and a fifth of a second of
+// carrier is a cheap way to find that out.
+const tciTXFirstAskTimeout = 200 * time.Millisecond
+
+// PlayTXAudio sends one message and returns when it has all been handed over,
+// or when stop is closed.
+//
+// The PTT is NOT touched here. The voice keyer keys before calling and unkeys
+// after, exactly as it does with a sound card, so the transmission is bracketed
+// by the same code whichever way the audio travels.
+func (t *TCI) PlayTXAudio(pcm []byte, rate, ch, bits int, stop <-chan struct{}) error {
+	t.mu.Lock()
+	connected := t.conn != nil
+	t.mu.Unlock()
+	if !connected {
+		return fmt.Errorf("not connected to the radio")
+	}
+
+	t.audio.mu.Lock()
+	outRate := t.audio.rate
+	t.audio.mu.Unlock()
+	if outRate <= 0 {
+		outRate = 48000
+	}
+
+	mono := decodeToMono(pcm, ch, bits)
+	if len(mono) == 0 {
+		return fmt.Errorf("the message is empty")
+	}
+	if rate > 0 && rate != outRate {
+		mono = resampleLinear(mono, rate, outRate)
+	}
+
+	// Served from here on. The callback does nothing but copy and interleave,
+	// which is what keeps it inside the frame interval.
+	pos := 0
+	done := make(chan struct{})
+	var closed bool
+	t.setTXFeed(func(samples int) []byte {
+		if samples <= 0 {
+			samples = 2048
+		}
+		pairs := samples / 2
+		if pos >= len(mono) {
+			if !closed {
+				closed = true
+				close(done)
+			}
+			return nil
+		}
+		payload := make([]byte, samples*4)
+		le := binary.LittleEndian
+		for i := 0; i < pairs; i++ {
+			var v float32
+			if pos < len(mono) {
+				v = mono[pos]
+				pos++
+			}
+			bits := math.Float32bits(v)
+			le.PutUint32(payload[(i*2)*4:], bits)   // left
+			le.PutUint32(payload[(i*2+1)*4:], bits) // right
+		}
+		return payload
+	})
+	defer t.setTXFeed(nil)
+
+	// Nothing asked for in a fifth of a second means nothing is listening.
+	// Reported plainly: the message would otherwise go out as silence, and a
+	// voice keyer that transmits silence is worse than one that refuses.
+	deadline := time.Now().Add(tciTXFirstAskTimeout)
+	for time.Now().Before(deadline) {
+		t.audio.mu.Lock()
+		asked := t.audio.txSent > 0
+		t.audio.mu.Unlock()
+		if asked {
+			break
+		}
+		select {
+		case <-stop:
+			return nil
+		case <-time.After(10 * time.Millisecond):
+		}
+	}
+	t.audio.mu.Lock()
+	asked := t.audio.txSent
+	t.audio.mu.Unlock()
+	if asked == 0 {
+		return fmt.Errorf("the radio did not ask for any audio — set its transmit audio source to TCI instead of the microphone")
+	}
+
+	// The radio drains the message at real time, so this waits for the feed to
+	// run out. The cap is the message's own length with a second to spare: a
+	// radio that stops asking mid-message must not hold the transmitter up.
+	limit := time.Duration(float64(len(mono))/float64(outRate)*float64(time.Second)) + time.Second
+	select {
+	case <-done:
+	case <-stop:
+	case <-time.After(limit):
+		debugLog.Printf("TCI: the radio stopped asking for audio before the message ended")
+	}
+	return nil
+}
+
+// decodeToMono turns interleaved PCM into one channel of -1…1 floats.
+func decodeToMono(pcm []byte, ch, bits int) []float32 {
+	if ch <= 0 {
+		ch = 1
+	}
+	switch bits {
+	case 16:
+		frame := ch * 2
+		out := make([]float32, 0, len(pcm)/frame+1)
+		for i := 0; i+frame <= len(pcm); i += frame {
+			var sum float32
+			for c := 0; c < ch; c++ {
+				v := int16(uint16(pcm[i+c*2]) | uint16(pcm[i+c*2+1])<<8)
+				sum += float32(v) / 32768
+			}
+			out = append(out, sum/float32(ch))
+		}
+		return out
+	case 8:
+		// Unsigned, centred on 128 — the one format where silence is not zero.
+		out := make([]float32, 0, len(pcm)/ch+1)
+		for i := 0; i+ch <= len(pcm); i += ch {
+			var sum float32
+			for c := 0; c < ch; c++ {
+				sum += (float32(pcm[i+c]) - 128) / 128
+			}
+			out = append(out, sum/float32(ch))
+		}
+		return out
+	}
+	return nil
+}
+
+// resampleLinear moves samples from one rate to another.
+//
+// Linear interpolation, which is crude and entirely adequate here: a voice
+// recording at 16 kHz going to 48 kHz is being INTERPOLATED, and interpolation
+// invents no frequencies to alias. Going the other way would want a filter
+// first, but a message recorded above the radio's stream rate is not a case
+// that arises — the recorder works at 16 kHz and radios stream at 48.
+func resampleLinear(in []float32, from, to int) []float32 {
+	if from <= 0 || to <= 0 || from == to || len(in) == 0 {
+		return in
+	}
+	ratio := float64(from) / float64(to)
+	n := int(float64(len(in)) / ratio)
+	out := make([]float32, n)
+	for i := 0; i < n; i++ {
+		src := float64(i) * ratio
+		j := int(src)
+		frac := float32(src - float64(j))
+		if j+1 < len(in) {
+			out[i] = in[j]*(1-frac) + in[j+1]*frac
+		} else {
+			out[i] = in[len(in)-1]
+		}
+	}
+	return out
+}

internal/cat/tci_tx_probe.go

@@ -0,0 +1,117 @@
+package cat
+
+// Sending audio TO the radio over TCI.
+//
+// Three transmissions on a real SunSDR settled how this works, and none of it
+// was guessable from the documentation:
+//
+//  1. The radio asks for audio only when the transmission is the CLIENT'S. With
+//     the operator keying the microphone it sent 282 receive frames and nothing
+//     else, over six seconds.
+//  2. It asks only when its TRANSMIT AUDIO SOURCE is TCI rather than the
+//     microphone. This first read as "digital modes only" — SSB produced
+//     nothing four times over, DIGU answered at once — but the mode was a
+//     coincidence: ExpertSDR3 keeps that source setting per mode, and it was on
+//     the microphone in SSB. Which is why nothing is refused on the strength of
+//     the mode: the radio is asked, and it answers by asking or by staying
+//     quiet.
+//  3. The chrono is a REQUEST, not a clock to follow. It carries no payload —
+//     the message itself is the ask — and it names the size it wants in the
+//     header's length field: 2048 samples, two channels interleaved, arriving
+//     47 times a second. Which is 1024 sample-pairs at 48 kHz, exactly real
+//     time, measured rather than assumed.
+//
+// So audio is sent in ANSWER to chrono, never on a timer of our own. A timer
+// was the first attempt and the radio ignored every frame of it: 234 sent, none
+// used. Answering the request is what makes the difference, and it also means
+// the radio sets the pace — no drift, no buffer to tune.
+//
+// All of it was established with a tone probe — key the radio, push a sine,
+// watch — which is gone now that it has served its purpose: it answered the
+// three questions above, confirmed 80 W out on a real SunSDR, and had no
+// business in front of an operator once the voice keyer worked. What is left is
+// the exchange it discovered, with tci_tx_play.go supplying the message.
+
+import (
+	"encoding/binary"
+	"fmt"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// sendBinaryFrame writes one TCI binary frame: the 16-word header the radio's
+// own frames carry, then the payload.
+func (t *TCI) sendBinaryFrame(stype, rx, rate, length int, payload []byte) error {
+	t.mu.Lock()
+	c := t.conn
+	t.mu.Unlock()
+	if c == nil {
+		return fmt.Errorf("tci: not connected")
+	}
+	buf := make([]byte, tciHeaderBytes+len(payload))
+	le := binary.LittleEndian
+	le.PutUint32(buf[0:], uint32(rx))
+	le.PutUint32(buf[4:], uint32(rate))
+	// format=3, codec=0: mirrored from what this radio SENDS. The field is
+	// documented as an enumeration whose numbering did not survive contact with
+	// the firmware — the receive stream answers 3 for four-byte floats — so the
+	// only defensible choice is to speak back exactly what was spoken to us.
+	le.PutUint32(buf[8:], 3)
+	le.PutUint32(buf[12:], 0)
+	le.PutUint32(buf[16:], 0) // crc — the radio sends 0 and does not check ours
+	le.PutUint32(buf[20:], uint32(length))
+	le.PutUint32(buf[24:], uint32(stype))
+	copy(buf[tciHeaderBytes:], payload)
+
+	t.wmu.Lock()
+	defer t.wmu.Unlock()
+	_ = c.SetWriteDeadline(time.Now().Add(3 * time.Second))
+	return c.WriteMessage(websocket.BinaryMessage, buf)
+}
+
+// serveChrono answers one request for transmit audio.
+//
+// Called from the reader goroutine, so it does the least it can: take the
+// frame from whatever is feeding, and write it. A feed that has run out returns
+// nil and the request is counted rather than answered with silence — silence
+// would be indistinguishable from a working stream on a meter.
+func (t *TCI) serveChrono(rate, samples int) {
+	t.audio.mu.Lock()
+	feed := t.audio.txFeed
+	t.audio.mu.Unlock()
+	if feed == nil {
+		return
+	}
+	if samples <= 0 {
+		samples = 2048
+	}
+	payload := feed(samples)
+	if payload == nil {
+		// Answered with silence rather than left unanswered. TCI 2.0 §3.4: "the
+		// client may not send a response or may send a signal with zero counts,
+		// which corresponds to no signal - this option is preferable."
+		payload = make([]byte, samples*4)
+		t.audio.mu.Lock()
+		t.audio.txShort++
+		t.audio.mu.Unlock()
+	}
+	if rate <= 0 {
+		rate = 48000
+	}
+	if err := t.sendBinaryFrame(tciStreamTXAudio, 0, rate, samples, payload); err != nil {
+		debugLog.Printf("TCI: could not send transmit audio: %v", err)
+		return
+	}
+	t.audio.mu.Lock()
+	t.audio.txSent++
+	t.audio.mu.Unlock()
+}
+
+// setTXFeed installs (or clears) the source of transmit audio.
+func (t *TCI) setTXFeed(fn func(samples int) []byte) {
+	t.audio.mu.Lock()
+	t.audio.txFeed = fn
+	t.audio.txSent, t.audio.txShort = 0, 0
+	t.audio.mu.Unlock()
+}

internal/integrations/udp/instances_test.go

@@ -0,0 +1,52 @@
+package udp
+
+import (
+	"net"
+	"testing"
+)
+
+// Two copies of MSHV call themselves "MSHV". WSJT-X refuses to start a second
+// instance without --rig-name, so its ids differ; MSHV has no such rule, and
+// everything a decode needs — the dial frequency, the T/R period, the mode —
+// used to be filed under the id alone.
+//
+// The consequence was reported from a real station: the second copy, on LF,
+// overwrote the dial of the first, and FT8 decodes made on 14.095 came out
+// labelled 2190 m — which is 136 kHz plus an audio offset, to the hertz.
+func TestSameProgramIDFromTwoAddressesAreTwoInstances(t *testing.T) {
+	s := &Server{}
+	a := &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2237}
+	b := &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2238}
+
+	first := s.instanceLabel("MSHV", a)
+	second := s.instanceLabel("MSHV", b)
+	if first == second {
+		t.Fatalf("two applications on different sockets share the label %q", first)
+	}
+	if first != "MSHV" {
+		t.Fatalf("the first instance should keep the plain id, got %q", first)
+	}
+
+	// Stable: the same socket must keep its name for as long as it runs, or the
+	// decodes panel would grow a new column every time a packet arrived.
+	if again := s.instanceLabel("MSHV", a); again != first {
+		t.Fatalf("label changed for the same address: %q then %q", first, again)
+	}
+	if again := s.instanceLabel("MSHV", b); again != second {
+		t.Fatalf("label changed for the same address: %q then %q", second, again)
+	}
+}
+
+// Distinct ids stay distinct without decoration — a station running WSJT-X and
+// MSHV should not see either renamed.
+func TestDifferentProgramIDsAreLeftAlone(t *testing.T) {
+	s := &Server{}
+	a := &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2237}
+	b := &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 2238}
+	if got := s.instanceLabel("WSJT-X", a); got != "WSJT-X" {
+		t.Fatalf("WSJT-X was renamed to %q", got)
+	}
+	if got := s.instanceLabel("MSHV", b); got != "MSHV" {
+		t.Fatalf("MSHV was renamed to %q", got)
+	}
+}

internal/integrations/udp/server.go

@@ -212,6 +212,21 @@ type Server struct {
 	// lastFrom is the address each program's packets arrive from — where a Reply
 	// has to be sent. See SendReply.
 	lastFrom map[string]*net.UDPAddr
+	// instLabel names each running application, keyed by id AND sending address.
+	//
+	// WSJT-X requires --rig-name for a second instance, so its ids differ. MSHV
+	// does not: two copies both call themselves "MSHV", and everything below was
+	// keyed on that name alone — so the second copy's Status overwrote the
+	// first's dial frequency, and decodes from the 20 m instance were placed at
+	// the LF instance's frequency. Reported as FT8 decodes on 14.095 labelled
+	// 2190 m, which is exactly 136 kHz plus an audio offset.
+	//
+	// The label is what the rest of OpsLog sees: the plain id for the first
+	// instance, then "MSHV #2", "MSHV #3"… so the decodes panel can still tell
+	// them apart on screen.
+	instLabel map[string]string
+	// instSeq counts how many distinct instances have claimed each id.
+	instSeq map[string]int
 	// lastMode is the mode NAME from each program's last Status, used to resolve
 	// a Decode's one-character mode marker.
 	lastMode map[string]string
@@ -374,6 +389,40 @@ func (s *Server) run() {
 	}
 }
 
+// instanceLabel returns the name for one running application, allocating it on
+// first sight. Caller holds s.mu.
+//
+// The address is part of the identity because the id is not enough: two copies
+// of MSHV send the same id from different sockets, and the two are different
+// radios on different bands. The port is included — a program keeps its socket
+// for as long as it runs, which is exactly the lifetime this has to be stable
+// over.
+func (s *Server) instanceLabel(id string, remote *net.UDPAddr) string {
+	if id == "" {
+		return ""
+	}
+	if remote == nil {
+		return id
+	}
+	key := id + "|" + remote.String()
+	if s.instLabel == nil {
+		s.instLabel = map[string]string{}
+		s.instSeq = map[string]int{}
+	}
+	if lbl, ok := s.instLabel[key]; ok {
+		return lbl
+	}
+	s.instSeq[id]++
+	lbl := id
+	if n := s.instSeq[id]; n > 1 {
+		lbl = fmt.Sprintf("%s #%d", id, n)
+		applog.Printf("udp: [%s] a second application calls itself %q (from %s) — it will be shown as %q",
+			s.cfg.Name, id, remote, lbl)
+	}
+	s.instLabel[key] = lbl
+	return lbl
+}
+
 // logBadPacket reports a datagram this listener could not parse, with enough of
 // it to identify the sender — then falls silent.
 //
@@ -464,14 +513,15 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 		// to it. Per PROGRAM, not per listener: two receivers share one multicast
 		// group, and a reply must reach the one that heard the station — and it
 		// must go to the sender's own address, never to the group.
-		if w.ProgramID != "" && remote != nil {
+		s.mu.Lock()
-			s.mu.Lock()
+		inst := s.instanceLabel(w.ProgramID, remote)
+		if inst != "" && remote != nil {
 			if s.lastFrom == nil {
 				s.lastFrom = map[string]*net.UDPAddr{}
 			}
-			s.lastFrom[w.ProgramID] = remote
+			s.lastFrom[inst] = remote
-			s.mu.Unlock()
 		}
+		s.mu.Unlock()
 		// Status carries the current dial frequency; remember it so Decode audio
 		// offsets can be turned into RF frequencies for the panadapter.
 		if w.FreqHz > 0 && !w.IsDecode {
@@ -479,7 +529,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			if s.dialHz == nil {
 				s.dialHz = map[string]int64{}
 			}
-			s.dialHz[w.ProgramID] = w.FreqHz
+			s.dialHz[inst] = w.FreqHz
 			// The T/R period travels with Status, and a decode has to be told
 			// which slot it belongs to — so it is remembered per program the
 			// same way the dial is.
@@ -487,7 +537,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				if s.trPeriod == nil {
 					s.trPeriod = map[string]int{}
 				}
-				s.trPeriod[w.ProgramID] = w.TRPeriod
+				s.trPeriod[inst] = w.TRPeriod
 			}
 			// The mode NAME, which only Status carries: a Decode gives the
 			// one-character marker instead. See DecodeModeName.
@@ -495,7 +545,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 				if s.lastMode == nil {
 					s.lastMode = map[string]string{}
 				}
-				s.lastMode[w.ProgramID] = w.Mode
+				s.lastMode[inst] = w.Mode
 			}
 			s.mu.Unlock()
 		}
@@ -507,13 +557,13 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.TxMessage = w.TxMessage
 			ev.Transmitting = w.Transmitting
 			ev.DECall = w.DECall
-			ev.ProgramID = w.ProgramID
+			ev.ProgramID = inst
 		}
 		if w.IsDecode {
 			s.mu.Lock()
-			dial := s.dialHz[w.ProgramID]
+			dial := s.dialHz[inst]
-			tr := s.trPeriod[w.ProgramID]
+			tr := s.trPeriod[inst]
-			statusMode := s.lastMode[w.ProgramID]
+			statusMode := s.lastMode[inst]
 			s.mu.Unlock()
 			if dial <= 0 {
 				// No Status from THIS instance yet. Guessing with another
@@ -534,7 +584,7 @@ func (s *Server) handle(pkt []byte, remote *net.UDPAddr) {
 			ev.DecodeTRPeriod = tr
 			ev.DecodeDial = dial
 			ev.DecodeOffAir = w.OffAir
-			ev.ProgramID = w.ProgramID
+			ev.ProgramID = inst
 			ev.DecodeDT = w.DeltaTime
 			ev.DecodeAudioHz = w.DeltaFreqHz
 			ev.DecodeMs = w.DecodeMsSinceMidnight

internal/powergenius/operate_test.go

@@ -0,0 +1,39 @@
+package powergenius
+
+import "testing"
+
+// The amplifier's status frame has no "operate=" field: its live state is in
+// "state", and that is what says whether the amp is in line. Reading only
+// operate= meant the flag was never read at all — OpsLog opened claiming
+// STANDBY on an amp that was operating, and the first press of the button
+// commanded the state it was already in.
+func TestOperateIsReadFromTheStateField(t *testing.T) {
+	cases := []struct {
+		state   string
+		operate bool
+		known   bool
+	}{
+		{"STANDBY", false, true},
+		{"OFF", false, true},
+		{"OPERATE", true, true},
+		// IDLE is the one that matters: the amp is IN LINE, simply not keyed.
+		// Reading it as standby is how the wrong state got on screen.
+		{"IDLE", true, true},
+		{"TRANSMIT_A", true, true},
+		{"idle", true, true}, // case is the firmware's business, not ours
+		// A state nobody has seen leaves the flag alone rather than guessing:
+		// claiming STANDBY on an amp that is in line is the error that matters.
+		{"WARMING_UP", false, false},
+		{"", false, false},
+	}
+	for _, c := range cases {
+		op, known := operateFromState(c.state)
+		if known != c.known {
+			t.Errorf("state %q: known = %v, want %v", c.state, known, c.known)
+			continue
+		}
+		if known && op != c.operate {
+			t.Errorf("state %q: operate = %v, want %v", c.state, op, c.operate)
+		}
+	}
+}

internal/powergenius/powergenius.go

@@ -159,6 +159,22 @@ func replyCode(reply string) string {
 	return strings.TrimSpace(p[1])
 }
 
+// operateFromState maps the amplifier's live state to "in line or not".
+//
+// Unknown states leave the flag alone rather than guessing: a state nobody has
+// seen is not evidence that the amp is standing by, and claiming STANDBY on an
+// amplifier that is in line is the error that matters here — it invites the
+// operator to "switch it on" and command the state it is already in.
+func operateFromState(state string) (operate, known bool) {
+	switch strings.ToUpper(strings.TrimSpace(state)) {
+	case "STANDBY", "OFF", "POWERED_OFF", "DISCONNECTED":
+		return false, true
+	case "OPERATE", "OPERATING", "IDLE", "RECEIVE", "RX", "TRANSMIT", "TRANSMIT_A", "TRANSMIT_B", "TX", "KEYED":
+		return true, true
+	}
+	return false, false
+}
+
 // SetOperate puts the amp in OPERATE (1) or STANDBY (0).
 func (c *Client) SetOperate(on bool) error {
 	v := "0"
@@ -349,6 +365,7 @@ func (c *Client) parse(resp string) {
 		c.lastRaw = data
 		applog.Printf("pgxl: status raw=%q", data)
 	}
+	sawOperate := false
 	for _, pair := range strings.Fields(data) {
 		kv := strings.SplitN(pair, "=", 2)
 		if len(kv) != 2 {
@@ -358,6 +375,7 @@ func (c *Client) parse(resp string) {
 		case "state":
 			c.status.State = kv[1]
 		case "operate":
+			sawOperate = true
 			c.status.Operate = kv[1] == "1"
 		case "fanmode":
 			dev := strings.ToUpper(kv[1])
@@ -387,6 +405,23 @@ func (c *Client) parse(resp string) {
 			c.status.PeakId, _ = strconv.ParseFloat(kv[1], 64)
 		}
 	}
+	// THE AMP DOES NOT SEND "operate=".
+	//
+	// Operate was therefore never read at all on this link: it stayed at the
+	// zero value until the operator pressed the button, so OpsLog opened
+	// claiming STANDBY on an amplifier that was in line — and the first press
+	// then commanded the state it was already in. Reported from a real PGXL.
+	//
+	// The live state IS in the frame, under "state", and the FlexRadio side of
+	// this same amplifier has been reading it that way all along (see
+	// flexAmp): anything but STANDBY/OFF means the amp is IN LINE. IDLE is
+	// operate — in line, not keyed.
+	if !sawOperate && c.status.State != "" {
+		if op, known := operateFromState(c.status.State); known {
+			c.status.Operate = op
+		}
+	}
+
 	c.statusMu.Unlock()
 }
 

internal/qso/bandstatus_test.go

@@ -0,0 +1,58 @@
+package qso
+
+import "testing"
+
+// The colour of a matrix cell is a claim about what the operator still needs,
+// and it was wrong for several releases: a callsign worked and not confirmed
+// outranked an entity CONFIRMED on the same band and mode, so a slot that was
+// finished showed as unfinished.
+//
+// Reported by VK4DX with the case that names itself: YB confirmed on 20m
+// digital, shown blue, because one unconfirmed YB station had also been worked
+// there.
+func TestBandStatusConfirmedOutranksWorked(t *testing.T) {
+	cases := []struct {
+		name                                     string
+		callWorked, callConfirmed, entityConfirm bool
+		want                                     string
+	}{
+		{"entity worked only", false, false, false, "dxcc_w"},
+		{"this call worked, nothing confirmed", true, false, false, "call_w"},
+		// The regression, in one line.
+		{"entity confirmed, this call worked but not confirmed", true, false, true, "dxcc_c"},
+		{"entity confirmed, this call not worked here", false, false, true, "dxcc_c"},
+		{"this call confirmed", true, true, true, "call_c"},
+		// A confirmed contact with this call implies it was worked, but the flags
+		// arrive from separate SQL aggregates and nothing guarantees the pair.
+		{"call confirmed without the worked flag", false, true, true, "call_c"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := bandStatusNames[bandStatusCode(c.callWorked, c.callConfirmed, c.entityConfirm)]
+			if got != c.want {
+				t.Errorf("bandStatusCode(worked=%v, callConf=%v, entityConf=%v) = %s, want %s",
+					c.callWorked, c.callConfirmed, c.entityConfirm, got, c.want)
+			}
+		})
+	}
+}
+
+// The ladder itself, stated once: every confirmed code must beat every worked
+// code. A future edit that reorders the constants fails here rather than in a
+// screenshot from an operator.
+func TestBandStatusLadderPutsConfirmedAbove(t *testing.T) {
+	for _, worked := range []int{stDxccW, stCallW} {
+		for _, confirmed := range []int{stDxccC, stCallC} {
+			if confirmed <= worked {
+				t.Errorf("%s (%d) does not outrank %s (%d)",
+					bandStatusNames[confirmed], confirmed, bandStatusNames[worked], worked)
+			}
+		}
+	}
+	if stCallC <= stDxccC {
+		t.Error("call_c must outrank dxcc_c: the callsign is the more specific claim")
+	}
+	if stCallW <= stDxccW {
+		t.Error("call_w must outrank dxcc_w for the same reason")
+	}
+}

internal/qso/qso.go

@@ -1895,7 +1895,8 @@ type WorkedBefore struct {
 
 	// Status grid driving the band×class matrix in the UI. One entry per
 	// (band, class) where ANY QSO exists in this DXCC. Only the highest
-	// status for that cell is kept (call_c > call_w > dxcc_c > dxcc_w).
+	// status for that cell is kept (call_c > dxcc_c > call_w > dxcc_w —
+	// confirmed outranks worked).
 	BandStatus []BandStatus `json:"band_status"`
 }
 
@@ -1906,6 +1907,48 @@ type BandStatus struct {
 	Status string `json:"status"` // "call_c" | "call_w" | "dxcc_c" | "dxcc_w"
 }
 
+// Band-status codes, lowest first. The ORDER is the rule: a cell shows the
+// highest that applies.
+const (
+	stDxccW = iota // the entity was worked on this slot
+	stCallW        // …and this callsign was one of them
+	stDxccC        // the entity is CONFIRMED here
+	stCallC        // …and by this callsign
+)
+
+// bandStatusNames maps those codes to what the UI colours by.
+var bandStatusNames = [...]string{"dxcc_w", "call_w", "dxcc_c", "call_c"}
+
+// bandStatusCode picks the status of one cell of the band × mode matrix.
+//
+// CONFIRMED OUTRANKS WORKED, and that is the whole of it. The ladder used to
+// run call_c > call_w > dxcc_c > dxcc_w, so a callsign worked and not confirmed
+// beat an entity confirmed on the same slot: an operator with YB confirmed on
+// 20m digital saw that cell as "worked, not confirmed" because he had also
+// worked one unconfirmed YB station there. The grid answers "what do I still
+// need", and a confirmed entity needs nothing, whoever was worked afterwards.
+//
+// Taken as a MAXIMUM rather than as a run of assignments, which is how the
+// later test came to overwrite the earlier one in the first place.
+func bandStatusCode(callWorked, callConfirmed, entityConfirmed bool) int {
+	code := stDxccW // there is a row at all ⇒ the entity was worked here
+	raise := func(c int) {
+		if c > code {
+			code = c
+		}
+	}
+	if callWorked {
+		raise(stCallW)
+	}
+	if entityConfirmed {
+		raise(stDxccC)
+	}
+	if callConfirmed {
+		raise(stCallC)
+	}
+	return code
+}
+
 // modeClass collapses ADIF modes into the three buckets DXers care about.
 // Anything not voice and not CW is treated as digital.
 func modeClass(mode string) string {
@@ -2167,7 +2210,18 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 	// ---- Per-(band, class) status grid ----
 	// One pass over every distinct (band, mode) in the DXCC, aggregating
 	// "did this call work it?" and "was anything confirmed?" via MAX.
-	// Status precedence: call_c > call_w > dxcc_c > dxcc_w.
+	// Status precedence: CONFIRMED OUTRANKS WORKED — call_c > dxcc_c > call_w >
+	// dxcc_w.
+	//
+	// It used to run call_c > call_w > dxcc_c > dxcc_w, which made a call worked
+	// and not confirmed outrank an entity confirmed on the same slot. Reported
+	// from a real log: YB confirmed on 20m digital showed BLUE, because that
+	// operator had also worked one unconfirmed YB station there. The cell said
+	// "not confirmed" about a slot that is confirmed.
+	//
+	// The grid answers "what do I still need on this band and mode", and for
+	// that question confirmation is the axis that matters: a confirmed entity
+	// needs nothing, whoever else was worked afterwards.
 	// Filter NULL/empty band+mode rows — they'd create a NULL group key
 	// that Scan into *string can't handle and would error out the whole
 	// WorkedBefore call, blanking the matrix in the UI.
@@ -2188,12 +2242,6 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 		return wb, fmt.Errorf("band status: %w", err)
 	}
 	type cellKey struct{ band, class string }
-	const (
-		stDxccW = 0
-		stDxccC = 1
-		stCallW = 2
-		stCallC = 3
-	)
 	best := map[cellKey]int{}
 	for statusRows.Next() {
 		var band, mode string
@@ -2202,23 +2250,14 @@ func (r *Repo) WorkedBefore(ctx context.Context, callsign string, dxccHint int,
 			statusRows.Close()
 			return wb, fmt.Errorf("scan band status: %w", err)
 		}
-		code := stDxccW // row exists ⇒ entity worked at minimum
+		code := bandStatusCode(callW == 1, callC == 1, dxccConfirmed == 1)
-		if dxccConfirmed == 1 {
-			code = stDxccC
-		}
-		if callW == 1 {
-			code = stCallW
-		}
-		if callC == 1 {
-			code = stCallC
-		}
 		k := cellKey{band: band, class: modeClass(mode)}
 		if cur, ok := best[k]; !ok || code > cur {
 			best[k] = code
 		}
 	}
 	statusRows.Close()
-	codeStr := [...]string{"dxcc_w", "dxcc_c", "call_w", "call_c"}
+	codeStr := bandStatusNames
 	for k, code := range best {
 		wb.BandStatus = append(wb.BandStatus, BandStatus{
 			Band: k.band, Class: k.class, Status: codeStr[code],

internal/rigctld/rigctld.go

@@ -44,7 +44,11 @@ import (
 // Rig is what the server needs from OpsLog's CAT manager. An interface, so this
 // package stays testable without a radio and without importing internal/cat.
 type Rig interface {
-	Freq() int64          // current TX frequency in Hz, 0 if unknown
+	// Freq is the frequency of the CURRENT VFO — where the operator is
+	// listening. Hamlib's "f" means the VFO in use, not the transmit one; the
+	// split TX frequency is a separate question, asked with "i". Answering "f"
+	// with the TX frequency invites a client to write it back as the dial.
+	Freq() int64          // current (RX) frequency in Hz, 0 if unknown
 	Mode() string         // ADIF mode (SSB, CW, FT8…)
 	Split() (bool, int64) // split on?, and the other VFO's frequency
 	SetFreq(hz int64) error

main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
+	wailswindows "github.com/wailsapp/wails/v2/pkg/options/windows"
 )
 
 //go:embed all:frontend/dist
@@ -87,14 +88,43 @@ func main() {
 	// A --post-update relaunch (from the auto-updater) may start while the previous
 	// instance is still exiting and holding the single-instance mutex — wait for it
 	// to free instead of bailing out. Then clear the old exe it left behind.
+	bootLogLaunch()
 	postUpdate := hasFlag(os.Args[1:], "--post-update")
 	if !acquireInstance(postUpdate) {
+		// SAID, not merely done. This exit is correct — a second instance would
+		// fight the first over the rig — but it happened in total silence: no
+		// window, no data folder, no log, which is indistinguishable from a
+		// program that died on its first instruction.
+		bootLog("another instance already holds the single-instance mutex - exiting")
+		fatalBox("OpsLog", "OpsLog is already running.\n\nLook for its window, or for a leftover OpsLog.exe in the Task Manager, and close it before starting another.")
+		return
+	}
+	bootLog("single-instance mutex acquired")
+
+	// The data folder is created BESIDE the executable, so a copy dropped into
+	// Program Files is refused the write by Windows — and that refusal ended the
+	// launch with nothing on screen and nothing in any file, since the only log
+	// OpsLog had was inside the folder it could not create.
+	if err := checkDataDirWritable(); err != nil {
+		bootLog("FATAL %v", err)
+		fatalBox("OpsLog", "OpsLog cannot write next to its own program file.\n\n"+err.Error()+
+			"\n\nMove OpsLog.exe somewhere your account can write — a folder in Documents, or the desktop — and start it again. Program Files is refused to anything not running as administrator.")
 		return
 	}
 	if postUpdate {
 		cleanupOldUpdateBinary()
 	}
 
+	// The WebView2 runtime, named before the window is attempted. Its absence is
+	// the classic silent failure — the process starts, the browser environment
+	// cannot be created, and on some machines that ends the launch without an
+	// error anyone can see.
+	if v := webView2Version(); v != "" {
+		bootLog("WebView2 runtime: %s", v)
+	} else {
+		bootLog("WebView2 runtime: NOT FOUND — install Microsoft Edge WebView2 Runtime")
+	}
+
 	// Create an instance of the app structure
 	app := NewApp()
 	app.startupProfile = profileArg(os.Args[1:])
@@ -116,6 +146,35 @@ func main() {
 	}
 
 	// Create application with options
+	// A HANG has no error to report, and that is the shape being chased here:
+	// the process stays up, the data folder is created and stays empty, and no
+	// window appears — WebView2 never finishes creating its environment, and
+	// nothing returns to be logged.
+	//
+	// So the absence of progress is what gets reported. If OnStartup has not
+	// been reached a few seconds in, this says so and names the two things that
+	// cause it, rather than leaving an operator watching a process that is doing
+	// nothing at all.
+	go func() {
+		time.Sleep(12 * time.Second)
+		if startupReached.Load() {
+			return
+		}
+		bootLog("STUCK: 12 s after wails.Run and the window has not started — WebView2 never handed control back")
+		fatalBox("OpsLog", startupStuckMessage)
+	}()
+	noteLaunchAttempt()
+	bootLog("Windows %s", windowsVersion())
+	bootLog("Edge policy: %s", edgePolicyNotes())
+	// The blocker utilities: they leave an IFEO entry that makes Windows refuse
+	// to run the WebView2 process at all. Named loudly, because a machine in
+	// this state looks identical to one with a broken graphics driver.
+	if blocked := edgeExecutionBlocked(); blocked != "" {
+		bootLog("EDGE EXECUTION IS BLOCKED: %s — an \"Edge blocker\" tool is stopping WebView2 from starting", blocked)
+		fatalBox("OpsLog", edgeBlockedMessage)
+	}
+	bootLog("WebView2 profile: %q", webviewDataPath())
+	bootLog("entering wails.Run (window %dx%d, state %v)", width, height, startState)
 	err := wails.Run(&options.App{
 		Title:            "OpsLog",
 		Width:            width,
@@ -140,16 +199,43 @@ func main() {
 		// graphite theme's background (#16181d), which is the default on a fresh
 		// install — otherwise every launch flashes white first.
 		BackgroundColour: &options.RGBA{R: 0x16, G: 0x18, B: 0x1d, A: 1},
-		OnStartup:        app.startup,
+		// WEBVIEW2, pinned down.
-		OnDomReady:       app.domReady,
+		//
-		OnBeforeClose:    app.beforeClose,
+		// Its profile folder is normally chosen by Wails under the roaming
-		OnShutdown:       app.shutdown,
+		// profile — a place that on a managed or redirected account can be slow,
+		// locked or simply gone, and the failure mode is a creation that never
+		// returns rather than an error. Naming it puts it on the local disk,
+		// beside the startup log, where it can also be DELETED when it is the
+		// thing that is broken.
+		//
+		// GPU acceleration is switched off only when the previous launch hung
+		// (see stuckMarker): a WebView2 that cannot get on with the graphics
+		// driver hangs exactly like one that cannot start at all, and this is the
+		// one lever that separates the two — without costing anything on the
+		// machines where it was never the problem.
+		Windows: &wailswindows.Options{
+			WebviewUserDataPath: webviewDataPath(),
+			// A fixed-version runtime carried beside OpsLog, when one is there.
+			// Empty means the installed Evergreen runtime, as before.
+			WebviewBrowserPath:   fixedWebView2Path(),
+			WebviewGpuIsDisabled: lastLaunchHung,
+		},
+		OnStartup:     app.startup,
+		OnDomReady:    app.domReady,
+		OnBeforeClose: app.beforeClose,
+		OnShutdown:    app.shutdown,
 		Bind: []interface{}{
 			app,
 		},
 	})
 
+	bootLog("wails.Run returned")
 	if err != nil {
-		println("Error:", err.Error())
+		// The last thing that can fail before a window exists, and the most
+		// opaque of them: a missing WebView2 runtime lands here. println goes
+		// nowhere in a GUI-subsystem program, so this went unseen and unlogged.
+		bootLog("FATAL wails.Run: %v", err)
+		fatalBox("OpsLog", "OpsLog could not open its window.\n\n"+err.Error()+
+			"\n\nThis is usually a missing WebView2 runtime — install \"Microsoft Edge WebView2 Runtime\" and try again.")
 	}
 }

rdacompare.go

@@ -80,8 +80,13 @@ func (a *App) CompareRDASources() (RDACompareResult, error) {
 	if a.qso == nil {
 		return res, fmt.Errorf("db not initialized")
 	}
+	// Said before the work starts, not only after: this reads the WHOLE log, and
+	// on a remote MySQL that is seconds of silence during which the only
+	// evidence that anything is happening is this line.
+	applog.Printf("rda compare: reading the log…")
 	rows, err := a.qso.List(a.ctx, qso.ListFilter{Limit: 1_000_000})
 	if err != nil {
+		applog.Printf("rda compare: reading the log failed: %v", err)
 		return res, err
 	}
 	for i := range rows {
@@ -143,3 +148,73 @@ func isHamlogConfirmed(v string) bool {
 	v = strings.ToUpper(strings.TrimSpace(v))
 	return v != "" && v != "N" && v != "NO"
 }
+
+// RDAChoice is one arbitrated contact: which district the operator decided is
+// right for that QSO.
+type RDAChoice struct {
+	QSOID    int64  `json:"qso_id"`
+	District string `json:"district"`
+}
+
+// RDAApplyResult reports what an arbitration did.
+type RDAApplyResult struct {
+	Applied int    `json:"applied"`
+	Failed  int    `json:"failed"`
+	Message string `json:"message"`
+}
+
+// ApplyRDAChoices writes the chosen district onto each contact — into CNTY and
+// as the award reference, both.
+//
+// The first version wrote only the award override, to keep the imported CNTY as
+// a record of what HAMLOG said. That was wrong in the way that matters: CNTY is
+// what the comparison READS, so the contact went on disagreeing for ever. The
+// operator settled a hundred contacts, ran the comparison again and got the
+// same hundred rows — the decision had no visible effect anywhere, which is
+// indistinguishable from a button that does nothing.
+//
+// So the chosen district lands in CNTY, where it settles the disagreement, and
+// in the award reference, where it decides what the contact counts for. This is
+// the operator's own log: correcting a field in it is the point of the exercise,
+// not a loss of evidence.
+func (a *App) ApplyRDAChoices(choices []RDAChoice) (RDAApplyResult, error) {
+	var res RDAApplyResult
+	if a.qso == nil {
+		return res, fmt.Errorf("db not initialized")
+	}
+	for _, c := range choices {
+		district := strings.ToUpper(strings.TrimSpace(c.District))
+		if !rdaDistrictRe.MatchString(district) {
+			res.Failed++
+			applog.Printf("rda apply: qso %d — %q is not a district reference", c.QSOID, c.District)
+			continue
+		}
+		q, err := a.qso.GetByID(a.ctx, c.QSOID)
+		if err != nil {
+			res.Failed++
+			applog.Printf("rda apply: qso %d could not be read: %v", c.QSOID, err)
+			continue
+		}
+		if q.Extras == nil {
+			q.Extras = map[string]string{}
+		}
+		q.County = district
+		q.Extras[award.ManualRefsKey] = setOverrideRef(q.Extras[award.ManualRefsKey], "RDA", district)
+		if err := a.qso.Update(a.ctx, q); err != nil {
+			res.Failed++
+			applog.Printf("rda apply: qso %d update failed: %v", c.QSOID, err)
+			continue
+		}
+		res.Applied++
+	}
+	if res.Applied > 0 {
+		// The award totals were computed from the old answers.
+		a.invalidateAwardStats()
+	}
+	applog.Printf("rda apply: %d contacts settled, %d failed", res.Applied, res.Failed)
+	res.Message = fmt.Sprintf("%d settled", res.Applied)
+	if res.Failed > 0 {
+		res.Message += fmt.Sprintf(", %d failed (see the log)", res.Failed)
+	}
+	return res, nil
+}

screenbounds_other.go

@@ -2,6 +2,13 @@
 
 package main
 
-// virtualScreenBounds is Windows-only; elsewhere we cannot tell, and the caller
+// The screen geometry helpers are Windows-only; elsewhere we cannot tell where
-// treats "cannot tell" as "trust the saved position".
+// the monitors are, and the callers treat "cannot tell" as "trust the operator's
+// saved position" rather than second-guessing it.
 func virtualScreenBounds() (x, y, w, h int, ok bool) { return 0, 0, 0, 0, false }
+
+func onSomeMonitorImpl(x, y, w, h int) bool { return true }
+
+func clampToVisible(x, y, w, h int) (int, int, bool) { return x, y, false }
+
+func logMonitorLayout() {}

screenbounds_windows.go

@@ -2,12 +2,17 @@
 
 package main
 
-import "syscall"
+import (
+	"fmt"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	"hamlog/internal/applog"
+)
 
 // GetSystemMetrics indices for the virtual desktop — the rectangle spanning
-// every attached monitor. Wails' ScreenGetAll reports each monitor's size but
+// every attached monitor.
-// not its offset, so it cannot answer "is this coordinate on any screen?"; the
-// Win32 metrics can.
 const (
 	smXVirtualScreen  = 76
 	smYVirtualScreen  = 77
@@ -16,8 +21,10 @@ const (
 )
 
 var (
-	user32Dll            = syscall.NewLazyDLL("user32.dll")
+	user32Dll               = syscall.NewLazyDLL("user32.dll")
-	procGetSystemMetrics = user32Dll.NewProc("GetSystemMetrics")
+	procGetSystemMetrics    = user32Dll.NewProc("GetSystemMetrics")
+	procEnumDisplayMonitors = user32Dll.NewProc("EnumDisplayMonitors")
+	procGetMonitorInfoW     = user32Dll.NewProc("GetMonitorInfoW")
 )
 
 func systemMetric(index int) int {
@@ -34,3 +41,86 @@ func virtualScreenBounds() (x, y, w, h int, ok bool) {
 	}
 	return systemMetric(smXVirtualScreen), systemMetric(smYVirtualScreen), w, h, true
 }
+
+// winRect is Win32's RECT.
+type winRect struct{ Left, Top, Right, Bottom int32 }
+
+// monitorInfo is MONITORINFO: the monitor's whole rectangle and its work area
+// (what is left once the taskbar is taken out).
+type monitorInfo struct {
+	CbSize    uint32
+	RcMonitor winRect
+	RcWork    winRect
+	DwFlags   uint32
+}
+
+// monitorRects enumerates the attached monitors.
+//
+// THE BOUNDING BOX IS NOT THE DESKTOP. The virtual screen is the rectangle that
+// spans every monitor, and monitors are rarely arranged to fill it: a wide
+// screen beside a tall one, or one offset vertically, leaves rectangular HOLES
+// inside the box that belong to no monitor at all. A window placed in a hole
+// passes a bounding-box test and is invisible — which is exactly what was
+// reported from a four-monitor station whose window.json held x=-7680.
+//
+// So the test has to be against the monitors themselves.
+func monitorRects() []screenRect {
+	var out []screenRect
+	cb := syscall.NewCallback(func(hMonitor, hdc uintptr, lprc *winRect, data uintptr) uintptr {
+		var mi monitorInfo
+		mi.CbSize = uint32(unsafe.Sizeof(mi))
+		if r, _, _ := procGetMonitorInfoW.Call(hMonitor, uintptr(unsafe.Pointer(&mi))); r != 0 {
+			// The WORK area, not the full rectangle: a title bar under the
+			// taskbar is a window that cannot be dragged, which is the fault
+			// being guarded against in the first place.
+			out = append(out, screenRect{
+				X: int(mi.RcWork.Left), Y: int(mi.RcWork.Top),
+				W: int(mi.RcWork.Right - mi.RcWork.Left),
+				H: int(mi.RcWork.Bottom - mi.RcWork.Top),
+			})
+		}
+		return 1 // keep enumerating
+	})
+	procEnumDisplayMonitors.Call(0, 0, cb, 0)
+	return out
+}
+
+// describeMonitors renders the layout for the log. A window that opens where
+// nobody can see it is reported as "OpsLog did not start", and the first
+// question is what the screens looked like at that moment.
+func describeMonitors(rects []screenRect) string {
+	if len(rects) == 0 {
+		return "none detected"
+	}
+	parts := make([]string, 0, len(rects))
+	for _, r := range rects {
+		parts = append(parts, fmt.Sprintf("%dx%d at %d,%d", r.W, r.H, r.X, r.Y))
+	}
+	return strings.Join(parts, " · ")
+}
+
+// onSomeMonitorImpl reports whether a window at these coordinates would land
+// where it can be seen and grabbed.
+func onSomeMonitorImpl(x, y, w, h int) bool {
+	rects := monitorRects()
+	if len(rects) == 0 {
+		// Enumeration failed. Fall back to the bounding box rather than refuse
+		// the operator's own saved position on the strength of a failed call.
+		vx, vy, vw, vh, ok := virtualScreenBounds()
+		if !ok {
+			return true
+		}
+		return overlapsEnough(x, y, w, h, vx, vy, vw, vh)
+	}
+	return onAnyScreen(x, y, w, h, rects)
+}
+
+// clampToVisible moves a window rectangle onto the monitor it is closest to.
+func clampToVisible(x, y, w, h int) (int, int, bool) {
+	return clampRectToScreens(x, y, w, h, monitorRects())
+}
+
+// logMonitorLayout writes the current screen arrangement once at startup.
+func logMonitorLayout() {
+	applog.Printf("window: monitors — %s", describeMonitors(monitorRects()))
+}

screenclamp.go

@@ -0,0 +1,75 @@
+package main
+
+// Placing a window on a set of monitors — the arithmetic, with no Win32 in it.
+//
+// Kept apart from the platform code so it can be tested: the fault it guards
+// against (a window that opens where nobody can see it) is reported as "OpsLog
+// does not start", is invisible by definition, and cannot be reproduced without
+// the reporter's screen layout. A table test can hold that layout.
+
+// screenRect is one monitor's work area, in virtual-desktop coordinates.
+type screenRect struct{ X, Y, W, H int }
+
+// screenRectOf is the same shape under the name the helpers below read with.
+type screenRectOf = screenRect
+
+// onAnyScreen reports whether a window would land where it can be seen and
+// grabbed on ONE of the screens.
+//
+// One of them, not their bounding box: monitors rarely tile the box they span,
+// and the leftover rectangles belong to no screen at all. A window in one of
+// those holes passes a bounding-box test and is invisible.
+func onAnyScreen(x, y, w, h int, screens []screenRectOf) bool {
+	for _, r := range screens {
+		if overlapsEnough(x, y, w, h, r.X, r.Y, r.W, r.H) {
+			return true
+		}
+	}
+	return false
+}
+
+// nearestScreen picks the screen whose centre is closest to the window's.
+func nearestScreen(x, y, w, h int, screens []screenRectOf) (screenRectOf, bool) {
+	if len(screens) == 0 {
+		return screenRectOf{}, false
+	}
+	best, bestDist := screens[0], int64(1)<<62
+	cx, cy := x+w/2, y+h/2
+	for _, r := range screens {
+		rcx, rcy := r.X+r.W/2, r.Y+r.H/2
+		dx, dy := int64(cx-rcx), int64(cy-rcy)
+		if d := dx*dx + dy*dy; d < bestDist {
+			best, bestDist = r, d
+		}
+	}
+	return best, true
+}
+
+// clampRectToScreens moves a window onto the nearest screen, keeping its size
+// where the screen can hold it. Returns the new position and whether it moved.
+func clampRectToScreens(x, y, w, h int, screens []screenRectOf) (int, int, bool) {
+	best, ok := nearestScreen(x, y, w, h, screens)
+	if !ok {
+		return x, y, false
+	}
+	if w > best.W {
+		w = best.W
+	}
+	if h > best.H {
+		h = best.H
+	}
+	nx, ny := x, y
+	if nx < best.X {
+		nx = best.X
+	}
+	if ny < best.Y {
+		ny = best.Y
+	}
+	if nx+w > best.X+best.W {
+		nx = best.X + best.W - w
+	}
+	if ny+h > best.Y+best.H {
+		ny = best.Y + best.H - h
+	}
+	return nx, ny, nx != x || ny != y
+}

screenclamp_test.go

@@ -0,0 +1,72 @@
+package main
+
+import "testing"
+
+// The layout that produced the report: four monitors in a row, the leftmost at
+// x=-7680, and a window.json holding exactly that corner.
+func fourAcross() []screenRectOf {
+	return []screenRectOf{
+		{X: -7680, Y: 0, W: 2560, H: 1392},
+		{X: -5120, Y: 0, W: 2560, H: 1392},
+		{X: -2560, Y: 0, W: 2560, H: 1392},
+		{X: 0, Y: 0, W: 2560, H: 1392},
+	}
+}
+
+func TestSavedCornerOnTheLeftMostMonitorIsAccepted(t *testing.T) {
+	if !onAnyScreen(-7680, 0, 2272, 1044, fourAcross()) {
+		t.Fatal("a window on the left-hand monitor was judged off-screen")
+	}
+}
+
+// The fault the bounding box could not see: monitors do not tile the rectangle
+// they span, and a window in the leftover space is invisible while passing a
+// bounding-box test.
+func TestAHoleBetweenMonitorsIsNotAScreen(t *testing.T) {
+	screens := []screenRectOf{
+		{X: 0, Y: 0, W: 1920, H: 1040},      // primary
+		{X: 1920, Y: -1080, W: 1920, H: 1040}, // second, mounted above and to the right
+	}
+	// Inside the bounding box (0..3840, -1080..1040), on neither monitor.
+	if onAnyScreen(2400, 600, 1200, 800, screens) {
+		t.Fatal("a window in the gap between two monitors was judged visible")
+	}
+}
+
+func TestAWindowInAHoleIsMovedOntoTheNearestScreen(t *testing.T) {
+	screens := []screenRectOf{
+		{X: 0, Y: 0, W: 1920, H: 1040},
+		{X: 1920, Y: -1080, W: 1920, H: 1040},
+	}
+	x, y, moved := clampRectToScreens(2400, 600, 1200, 800, screens)
+	if !moved {
+		t.Fatal("the window was left where nobody can see it")
+	}
+	if !onAnyScreen(x, y, 1200, 800, screens) {
+		t.Fatalf("moved to %d,%d, which is still not on a screen", x, y)
+	}
+}
+
+// A window wider than the screen it is moved to must still have its top-left
+// corner on that screen — clamping the right edge first would push the corner
+// off to the left, which is the same fault wearing a different hat.
+func TestAWindowTooBigForTheScreenKeepsItsCornerVisible(t *testing.T) {
+	screens := []screenRectOf{{X: 0, Y: 0, W: 1280, H: 800}}
+	x, y, _ := clampRectToScreens(-9000, -9000, 2560, 1440, screens)
+	if x < 0 || y < 0 {
+		t.Fatalf("corner at %d,%d is off the screen", x, y)
+	}
+}
+
+// The saved position is only refused when it is genuinely lost. The rule is
+// overlapsEnough's: a real slab of title bar — 160x32 — has to be visible, so a
+// window hanging well over the edge is kept and a sliver is not.
+func TestAWindowMostlyOffTheEdgeKeepsEnoughToGrab(t *testing.T) {
+	screens := []screenRectOf{{X: 0, Y: 0, W: 1920, H: 1040}}
+	if !onAnyScreen(1700, 900, 1200, 800, screens) { // 220 px still showing
+		t.Fatal("a window with 220 px on screen was judged off-screen")
+	}
+	if onAnyScreen(1850, 900, 1200, 800, screens) { // 70 px: not enough to grab
+		t.Fatal("a 70 px sliver was judged grabbable")
+	}
+}

telemetry.go

@@ -21,7 +21,7 @@ import (
 
 const (
 	// appVersion is stamped on every heartbeat (and could feed the About box).
-	appVersion = "0.26.12"
+	appVersion = "0.26.17"
 
 	// posthogHost is the PostHog ingestion endpoint. EU cloud by default; change
 	// to https://us.i.posthog.com for a US project.

webview2_other.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package main
+
+// webView2Version is a Windows question; elsewhere the browser engine comes
+// with the platform.
+func webView2Version() string { return "n/a" }
+
+// windowsVersion is a Windows question too.
+func windowsVersion() string { return "n/a" }
+
+// edgePolicyNotes is a Windows question too.
+func edgePolicyNotes() string { return "n/a" }
+
+// edgeExecutionBlocked is a Windows question too.
+func edgeExecutionBlocked() string { return "" }

webview2_windows.go

@@ -0,0 +1,137 @@
+//go:build windows
+
+package main
+
+// Is the WebView2 runtime actually installed?
+//
+// It is the one dependency OpsLog cannot ship inside its own executable, and
+// its absence is invisible: the process starts, Wails fails to create the
+// browser environment, and on some machines that failure arrives as a silent
+// exit rather than as an error we can print. So the version is read straight
+// from where the runtime registers itself, and written to the startup log
+// BEFORE the window is attempted — a log that says "WebView2: not found"
+// answers the whole question in one line.
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/sys/windows/registry"
+)
+
+// webview2Client is the runtime's own update-client GUID, the key it registers
+// its version under. Documented by Microsoft for exactly this check.
+const webview2Client = `Software\Microsoft\EdgeUpdate\Clients\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}`
+
+// webView2Version returns the installed runtime version, or "" if there is none.
+//
+// Both hives: a per-machine install writes to HKLM (and to the WOW6432 view of
+// it on 64-bit Windows, which is where it usually lands), a per-user install to
+// HKCU. Missing all three is the answer that matters.
+func webView2Version() string {
+	type place struct {
+		key    registry.Key
+		access uint32
+	}
+	for _, p := range []place{
+		{registry.CURRENT_USER, registry.QUERY_VALUE},
+		{registry.LOCAL_MACHINE, registry.QUERY_VALUE},
+		{registry.LOCAL_MACHINE, registry.QUERY_VALUE | registry.WOW64_32KEY},
+	} {
+		k, err := registry.OpenKey(p.key, webview2Client, p.access)
+		if err != nil {
+			continue
+		}
+		v, _, err := k.GetStringValue("pv")
+		k.Close()
+		if err == nil && v != "" && v != "0.0.0.0" {
+			return v
+		}
+	}
+	return ""
+}
+
+// windowsVersion reads the build from the registry, for the startup log.
+//
+// Not curiosity: "WebView2 will not install either" is a statement about the
+// machine, not about OpsLog, and the build number is the first thing anyone
+// diagnosing that will ask for.
+func windowsVersion() string {
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE,
+		`SOFTWARE\Microsoft\Windows NT\CurrentVersion`, registry.QUERY_VALUE)
+	if err != nil {
+		return "unknown"
+	}
+	defer k.Close()
+	name, _, _ := k.GetStringValue("ProductName")
+	build, _, _ := k.GetStringValue("CurrentBuild")
+	ubr, _, _ := k.GetIntegerValue("UBR")
+	display, _, _ := k.GetStringValue("DisplayVersion")
+	return fmt.Sprintf("%s %s build %s.%d", name, display, build, ubr)
+}
+
+// edgePolicyNotes reports the administrative policies applied to Edge, which is
+// the engine WebView2 runs on.
+//
+// "Edge is blocked on this PC" is a sentence about group policy, and policy is
+// readable: rather than have an operator guess which rule is in the way, the
+// names of the values under the Edge policy key go into the startup log. It is
+// evidence for whoever administers that machine, in the one file we can be sure
+// they will be sent.
+//
+// Value NAMES only, never their contents: a policy key can hold URLs, account
+// names and site lists that are nobody's business here.
+func edgePolicyNotes() string {
+	var found []string
+	for _, hive := range []registry.Key{registry.LOCAL_MACHINE, registry.CURRENT_USER} {
+		k, err := registry.OpenKey(hive, `SOFTWARE\Policies\Microsoft\Edge`, registry.QUERY_VALUE|registry.ENUMERATE_SUB_KEYS)
+		if err != nil {
+			continue
+		}
+		names, _ := k.ReadValueNames(0)
+		subs, _ := k.ReadSubKeyNames(0)
+		k.Close()
+		where := "HKLM"
+		if hive == registry.CURRENT_USER {
+			where = "HKCU"
+		}
+		if len(names) > 0 || len(subs) > 0 {
+			found = append(found, fmt.Sprintf("%s: %d policy values, %d sub-keys %v", where, len(names), len(subs), names))
+		}
+	}
+	if len(found) == 0 {
+		return "no Edge policies set"
+	}
+	return strings.Join(found, " | ")
+}
+
+// edgeExecutionBlocked reports an Image File Execution Options entry that stops
+// the WebView2 process from running.
+//
+// This is what the "Edge blocker" utilities do: they register a Debugger value
+// under IFEO for msedge.exe and msedgewebview2.exe, which makes Windows launch
+// something else — usually nothing — in its place. The WebView2 runtime is
+// installed, it registers its version, and it never starts, which is exactly
+// the hang OpsLog was showing. Confirmed on a real machine: an Edge blocker was
+// in the way, and unblocking it fixed the launch.
+//
+// One line in the startup log instead of an afternoon.
+func edgeExecutionBlocked() string {
+	const ifeo = `SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\`
+	var hits []string
+	for _, exe := range []string{"msedge.exe", "msedgewebview2.exe"} {
+		k, err := registry.OpenKey(registry.LOCAL_MACHINE, ifeo+exe, registry.QUERY_VALUE)
+		if err != nil {
+			continue
+		}
+		dbg, _, err := k.GetStringValue("Debugger")
+		k.Close()
+		if err == nil && strings.TrimSpace(dbg) != "" {
+			hits = append(hits, fmt.Sprintf("%s → Debugger=%q", exe, dbg))
+		}
+	}
+	if len(hits) == 0 {
+		return ""
+	}
+	return strings.Join(hits, " | ")
+}