chore: release v0.26.18

It has not shipped yet, so an operator reading about the SunSDR console
should meet what it does — not a list of repairs to a thing they have
never run.

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

@@ -43,6 +43,7 @@ import (
 	"hamlog/internal/geo"
 	"hamlog/internal/gridcache"
 	"hamlog/internal/integrations/udp"
+	"hamlog/internal/kpa"
 	"hamlog/internal/lookup"
 	"hamlog/internal/lotwusers"
 	"hamlog/internal/netctl"
@@ -106,6 +107,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 +134,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 +466,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 +528,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 +799,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 +808,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 +995,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 +1560,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 +2126,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 +2165,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 +2188,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 +3355,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 +8069,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 +8292,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 +8351,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 +8495,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 +8553,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
 	}
@@ -12646,6 +12739,21 @@ func (a *App) enrichContactedFromCtyForce(q *qso.QSO) bool {
 	if a.dxcc == nil || q.Callsign == "" {
 		return false
 	}
+	// A DELETED ENTITY IS LEFT ALONE, whatever cty.dat says about the callsign
+	// today.
+	//
+	// cty.dat answers "where is this call now". For a contact made before an
+	// entity was deleted that is the wrong question: R1MVI was Malyj Vysotskij
+	// (151) until 2012 and resolves to European Russia (54) today, so forcing
+	// the lookup onto a 2004 QSO destroys a credit that can never be worked
+	// again — the place does not exist to be worked. Reported from a Logger32
+	// export whose <DXCC:3>151 came back as 54.
+	//
+	// Nothing is corrected here rather than only the number: the country name
+	// and the zones of a deleted entity are equally beyond cty.dat's knowledge.
+	if q.DXCC != nil && dxcc.IsDeleted(*q.DXCC) {
+		return false
+	}
 	m, ok := a.dxcc.Lookup(q.Callsign)
 	if !ok || m.Entity == nil {
 		return false
@@ -15141,6 +15249,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 +15304,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":
@@ -15262,7 +15377,14 @@ func (a *App) reloadCAT() {
 		a.cat.Start(cat.NewIcomNet(s.IcomNetHost, s.IcomNetUser, s.IcomNetPass, s.IcomAddr, s.DigitalDefault, audioSink))
 	case "tci":
 		// Expert Electronics TCI (WebSocket) — SunSDR / ExpertSDR2, or any
-		// TCI-compatible server.
+		// TCI-compatible server. The receive audio rides the same socket, so
+		// the QSO recorder can take it without a virtual cable — see
+		// 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) {
@@ -15381,6 +15503,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...)
 	}
@@ -15396,6 +15521,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
 }
 
@@ -15435,6 +15564,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
 }
 
@@ -17647,6 +17784,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.
@@ -17655,13 +17798,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
 }
 
@@ -17671,9 +17820,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
@@ -17940,6 +18091,7 @@ type ampInst struct {
 	pgxl   *powergenius.Client
 	spe    *spe.Client
 	acom   *acom.Client
+	kpa    *kpa.Client
 	catemu *catemu.Server // Kenwood-format responder for band-follow (ACOM)
 }
 
@@ -17953,6 +18105,9 @@ func (i *ampInst) stopAll() {
 	if i.acom != nil {
 		i.acom.Stop()
 	}
+	if i.kpa != nil {
+		i.kpa.Stop()
+	}
 	if i.catemu != nil {
 		i.catemu.Stop()
 	}
@@ -17966,7 +18121,9 @@ func ampTypeLabel(t string) string {
 	case strings.HasPrefix(t, "spe"):
 		return "SPE " + map[string]string{"spe13": "1.3K-FA", "spe15": "1.5K-FA", "spe2k": "2K-FA"}[t]
 	case strings.HasPrefix(t, "acom"):
-		return "ACOM " + strings.TrimPrefix(t, "acom") + "S"
+		return "Acom " + strings.TrimPrefix(t, "acom") + "S"
+	case strings.HasPrefix(t, "kpa"):
+		return "Elecraft " + strings.ToUpper(t)
 	}
 	return t
 }
@@ -18078,6 +18235,19 @@ func (a *App) startAmps() {
 			if a.acom == nil {
 				a.acom = inst.acom
 			}
+		case strings.HasPrefix(c.Type, "kpa"):
+			// A KPA500 has no network port at all, so a configuration asking for
+			// one is a mistake worth naming rather than a connection that never
+			// succeeds.
+			if strings.EqualFold(c.Type, "kpa500") && c.Transport == "tcp" {
+				applog.Printf("amp %s: a KPA500 has no network connection — use its serial port", c.Name)
+				continue
+			}
+			inst.kpa = kpa.New(kpa.Config{
+				Model: strings.ToUpper(c.Type), Transport: c.Transport,
+				ComPort: c.ComPort, Baud: c.Baud, Host: c.Host, Port: c.Port,
+			})
+			_ = inst.kpa.Start()
 		default: // spe*
 			inst.spe = spe.New(spe.Config{Transport: c.Transport, ComPort: c.ComPort, Baud: c.Baud, Host: c.Host, Port: c.Port})
 			_ = inst.spe.Start()
@@ -18123,6 +18293,22 @@ func (a *App) feedAmpBandFollow(s cat.RigState) {
 			inst.catemu.SetFrequency(s.FreqHz)
 			inst.catemu.SetMode(s.Mode)
 		}
+		// A KPA is TOLD its band, on the link it is already on.
+		//
+		// The emulator above exists because an Acom polls a transceiver and has
+		// no command to be given a band; the KPA has one (^BN), so it needs
+		// neither a second serial port nor a pretend rig. Sent from a goroutine
+		// because this runs on the CAT state-change path, and nothing about the
+		// rig should wait on an amplifier's link.
+		// Asked for, like every other write to somebody's station. The option is
+		// the same one an Acom uses — "keep the amplifier on the radio's band" is
+		// one idea to an operator, whatever it takes underneath — and it is off
+		// for the operator who has wired the amplifier straight to the rig and
+		// does not want a second voice telling it where to be.
+		if inst.kpa != nil && inst.cfg.FreqOut && s.Band != "" {
+			k, band := inst.kpa, s.Band
+			go func() { _ = k.SetBand(band) }()
+		}
 	}
 }
 
@@ -18149,6 +18335,7 @@ type AmpStatus struct {
 	PGXL *powergenius.Status `json:"pgxl,omitempty"`
 	SPE  *spe.Status         `json:"spe,omitempty"`
 	ACOM *acom.Status        `json:"acom,omitempty"`
+	KPA  *kpa.Status         `json:"kpa,omitempty"`
 }
 
 // GetAmpStatuses returns the live state of every ENABLED amplifier, in the
@@ -18175,6 +18362,9 @@ func (a *App) GetAmpStatuses() []AmpStatus {
 			case inst.acom != nil:
 				v := inst.acom.GetStatus()
 				st.ACOM = &v
+			case inst.kpa != nil:
+				v := inst.kpa.GetStatus()
+				st.KPA = &v
 			}
 		}
 		out = append(out, st)
@@ -18256,6 +18446,8 @@ func (a *App) ampOperateOne(id string, on bool) error {
 		return inst.spe.Operate(on)
 	case inst.acom != nil:
 		return inst.acom.Operate(on)
+	case inst.kpa != nil:
+		return inst.kpa.Operate(on)
 	}
 	return fmt.Errorf("amplifier not running")
 }
@@ -18292,6 +18484,11 @@ func (a *App) ampPowerOne(id string, on, linked bool) error {
 			return inst.acom.PowerOn()
 		}
 		return inst.acom.PowerOff()
+	case inst.kpa != nil:
+		// OFF is a real power-down on a KPA1500: the main supplies drop and the
+		// way back on is the front panel or Wake-on-LAN. The button that reaches
+		// this asks first — see the UI — because "off" here is not standby.
+		return inst.kpa.PowerOn(on)
 	}
 	// Not an error worth surfacing when linked: a PGXL alongside two SPEs simply
 	// has no power command on its direct link, and reporting that as a failure
@@ -18387,7 +18584,7 @@ func (a *App) GetACOMStatus() acom.Status {
 // protocol has explicit commands for each, unlike the SPE's toggle key.
 func (a *App) ACOMSetOperate(on bool) error {
 	if a.acom == nil {
-		return fmt.Errorf("ACOM amplifier not connected — enable it in Settings → Amplifier")
+		return fmt.Errorf("Acom amplifier not connected — enable it in Settings → Amplifier")
 	}
 	return a.acom.Operate(on)
 }
@@ -18396,7 +18593,7 @@ func (a *App) ACOMSetOperate(on bool) error {
 // the power-on pins wired in the cable) or off (false, the OFF data command).
 func (a *App) ACOMSetPower(on bool) error {
 	if a.acom == nil {
-		return fmt.Errorf("ACOM amplifier not connected — enable it in Settings → Amplifier")
+		return fmt.Errorf("Acom amplifier not connected — enable it in Settings → Amplifier")
 	}
 	if on {
 		return a.acom.PowerOn()
@@ -19940,7 +20137,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 —
@@ -20337,8 +20554,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_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_panel.go

@@ -0,0 +1,118 @@
+package main
+
+// The TCI control console — bindings.
+//
+// Thin on purpose: the state is a snapshot the radio pushed and the setters are
+// one command each. Everything interesting is in internal/cat/tci_panel.go.
+
+import (
+	"fmt"
+
+	"hamlog/internal/cat"
+)
+
+// GetTCIPanel returns the console state. Connected=false when the active CAT
+// backend is not a TCI radio, so the frontend has one thing to look at rather
+// than an error to distinguish from a disconnected radio.
+func (a *App) GetTCIPanel() cat.TCIPanelState {
+	if a.cat == nil {
+		return cat.TCIPanelState{}
+	}
+	st, _ := a.cat.TCIPanelState()
+	return st
+}
+
+// tciDo is the shape every setter below takes.
+func (a *App) tciDo(fn func(cat.TCIPanelController) error) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.TCIPanelDo(fn)
+}
+
+// SetTCIDrive sets the transmit drive (0-100).
+func (a *App) SetTCIDrive(v int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetDrive(v) })
+}
+
+// SetTCITuneDrive sets the drive TUNE uses (0-100).
+func (a *App) SetTCITuneDrive(v int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetTuneDrive(v) })
+}
+
+// SetTCIMicLevel sets the microphone gain (0-100).
+func (a *App) SetTCIMicLevel(v int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetMicLevel(v) })
+}
+
+// SetTCIVolume sets the receive volume in dB (0 down to -60).
+func (a *App) SetTCIVolume(db int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetVolume(db) })
+}
+
+// SetTCIMute mutes or unmutes the receiver.
+func (a *App) SetTCIMute(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetMute(on) })
+}
+
+// SetTCIAGC picks the AGC speed: off, long, slow, med, fast.
+func (a *App) SetTCIAGC(mode string) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetAGC(mode) })
+}
+
+// SetTCISquelch turns the squelch on or off.
+func (a *App) SetTCISquelch(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetSquelch(on) })
+}
+
+// SetTCISquelchLevel sets the squelch threshold in dBm.
+func (a *App) SetTCISquelchLevel(v int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetSquelchLevel(v) })
+}
+
+// SetTCINB, SetTCINR, SetTCIANF and SetTCIAPF switch the receive processing.
+func (a *App) SetTCINB(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetNB(on) })
+}
+func (a *App) SetTCINR(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetNR(on) })
+}
+func (a *App) SetTCIANF(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetANF(on) })
+}
+func (a *App) SetTCIAPF(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetAPF(on) })
+}
+
+// SetTCIFilter sets the passband edges in Hz.
+func (a *App) SetTCIFilter(lo, hi int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetFilter(lo, hi) })
+}
+
+// SetTCIRIT / SetTCIXIT switch the offsets on; the Offset calls move them.
+func (a *App) SetTCIRIT(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetRIT(on) })
+}
+func (a *App) SetTCIXIT(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetXIT(on) })
+}
+func (a *App) SetTCIRITOffset(hz int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetRITOffset(hz) })
+}
+func (a *App) SetTCIXITOffset(hz int) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetXITOffset(hz) })
+}
+
+// SetTCILock locks the radio's VFO knob.
+func (a *App) SetTCILock(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetLock(on) })
+}
+
+// SetTCITune starts or stops the tune carrier.
+//
+// IT TRANSMITS, and at tune_drive rather than at drive — which is why the panel
+// shows those two numbers next to the button rather than hiding one of them in
+// a menu.
+func (a *App) SetTCITune(on bool) error {
+	return a.tciDo(func(t cat.TCIPanelController) error { return t.SetTune(on) })
+}

app_tci_rec.go

@@ -0,0 +1,98 @@
+package main
+
+// Feeding the QSO recorder from the TCI stream.
+//
+// The recorder works in 16 kHz mono, which is what its files and its mixing are
+// built around; TCI delivers 48 kHz stereo float32. The conversion is the whole
+// of this file, and it happens here rather than in internal/cat because the
+// radio's job is to hand over what it sent, not to know what the recorder wants.
+//
+// Confirmed on a SunSDR (ExpertSDR3 1.5): 2048 samples a frame, 8192 bytes,
+// four bytes per sample — and a test recording that plays back clean.
+
+import (
+	"encoding/binary"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/audio"
+	"hamlog/internal/cat"
+)
+
+// tciRecordSink pushes the receive stream into the QSO recorder.
+//
+// Installed whenever the TCI backend starts, and harmless when nothing is
+// recording: PushRX drops what arrives unless a QSO is being captured, so the
+// cost while idle is a decimation and a function call.
+func (a *App) tciRecordSink(rate int, samples []float32) {
+	if a.qsoRec == nil || len(samples) == 0 {
+		return
+	}
+	a.qsoRec.PushRX(tciToRecorderPCM(rate, samples))
+}
+
+// tciToRecorderPCM converts the stream's mono float samples to the recorder's
+// 16-bit PCM at its own rate.
+//
+// Averaging rather than picking every third sample: dropping samples aliases
+// everything above 8 kHz back down into the voice band, and on a receiver that
+// is hiss — the one thing a QSO recording has plenty of. A three-tap mean is a
+// crude low-pass, but it is a low-pass, and it costs two additions.
+func tciToRecorderPCM(rate int, samples []float32) []byte {
+	if rate <= 0 {
+		rate = 48000
+	}
+	step := rate / audio.RecorderSampleRate
+	if step < 1 {
+		step = 1
+	}
+	out := make([]byte, 0, (len(samples)/step)*2)
+	for i := 0; i+step <= len(samples); i += step {
+		var sum float32
+		for j := 0; j < step; j++ {
+			sum += samples[i+j]
+		}
+		v := sum / float32(step)
+		if v > 1 {
+			v = 1
+		}
+		if v < -1 {
+			v = -1
+		}
+		var b [2]byte
+		binary.LittleEndian.PutUint16(b[:], uint16(int16(v*32767)))
+		out = append(out, b[0], b[1])
+	}
+	return out
+}
+
+// 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 by choosing the radio as their receive device: opening a 384 kB/s
+// stream on a station that records nothing is work the radio does for nobody.
+func (a *App) startTCIRecording() {
+	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 {
+		if s, ok := t.(interface {
+			SetTCIAudioSink(func(int, []float32))
+		}); ok {
+			s.SetTCIAudioSink(a.tciRecordSink)
+		}
+		return t.StartTCIAudio(0, 48000)
+	})
+	if err != nil {
+		applog.Printf("tci: could not open the receive stream for recording: %v", err)
+		return
+	}
+	applog.Printf("tci: recording the receive audio over TCI — no virtual cable needed")
+}

app_tci_rec_test.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"encoding/binary"
+	"testing"
+
+	"hamlog/internal/audio"
+)
+
+// The stream is 48 kHz and the recorder works at 16 — three to one. A
+// recording that keeps every sample plays back three times too fast, which is
+// the fault that gets blamed on the decoding rather than on the rate.
+func TestTheStreamIsResampledToTheRecorderRate(t *testing.T) {
+	const in = 48000
+	samples := make([]float32, in/10) // a tenth of a second
+	pcm := tciToRecorderPCM(in, samples)
+	want := (audio.RecorderSampleRate / 10) * 2 // 16-bit
+	if len(pcm) != want {
+		t.Fatalf("a tenth of a second produced %d bytes, want %d", len(pcm), want)
+	}
+}
+
+// Full scale must arrive as full scale: a conversion that quietly halves the
+// level turns a recording into evidence of a fault that is not there.
+func TestFullScaleSurvivesTheConversion(t *testing.T) {
+	samples := make([]float32, 12)
+	for i := range samples {
+		samples[i] = 1
+	}
+	pcm := tciToRecorderPCM(48000, samples)
+	if len(pcm) < 2 {
+		t.Fatal("no samples came out")
+	}
+	v := int16(binary.LittleEndian.Uint16(pcm[:2]))
+	if v < 32000 {
+		t.Fatalf("full scale came out at %d", v)
+	}
+}
+
+// A rate the recorder already works in is passed through rather than mangled by
+// a division that would round to nothing.
+func TestAStreamAtTheRecorderRateIsNotDecimated(t *testing.T) {
+	samples := make([]float32, 160)
+	if got, want := len(tciToRecorderPCM(audio.RecorderSampleRate, samples)), 160*2; got != want {
+		t.Fatalf("%d bytes, want %d", got, want)
+	}
+}

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,4 +1,124 @@
 [
+  {
+    "version": "0.26.18",
+    "date": "",
+    "en": [
+      "Awards: the band matrix shows the bands you have contacts on — no more, and no longer capped at 70cm. It used to list every band the award permits, so DDFM stood there with empty 6m and 70cm columns, and it could not show 23cm at all whatever the award said.",
+      "Elecraft KPA500 and KPA1500 amplifiers, over serial or — on the KPA1500 — over the network. Operate/standby, on/off, power, SWR, temperature, supply voltage and current, the band, and faults named in plain words rather than as a code. They join the SPE, the Acom and the PowerGenius, so linking several amplifiers works on them too. NEW, AND NOT YET TESTED ON A REAL AMPLIFIER: it is written from Elecraft's programming reference, so please report what it does.",
+      "The Elecraft amplifiers follow the radio's band by themselves, on the link already open — they have a band command of their own, so no second serial port is involved. It can be turned off for an amplifier wired straight to the radio.",
+      "The Light and Voyager maps came up stamped 'API KEY REQUIRED' across the middle. Carto now watermarks its key-free tiles, so both views move to Esri, the provider already behind Street and Satellite. Light looks the same; Voyager is now a topographic map and is named Topo — anyone who had it selected keeps it.",
+      "Ultrabeam / SteppIR over USB: the COM port can be picked from the list again. It used a field you could also type into, and the list could not be selected from at all.",
+      "A control console for SunSDR / ExpertSDR3, as a tab and as a docked pane: drive and tune drive, mic gain, TUNE, power and SWR while transmitting, volume, mute, squelch, NB, NR, ANF, APF in CW, AGC, filters chosen per mode, RIT and XIT, the VFO lock, and an S-meter reading real dBm. Levels can be dragged, scrolled, stepped or typed. It follows the radio's own window — TCI announces every change, whoever made it.",
+      "The Elecraft console can be docked as a main-view pane. It always could; the setting simply never listed it.",
+      "Spot alerts name the right mode. A 30 m FT8 spot raised an alert saying SSB while the cluster list beside it said DATA: the alert engine had its own, coarser band plan, which called everything above 10.130 phone. Both now read the same table, and a frequency the plan does not cover is left unnamed rather than guessed at.",
+      "Awards: editing an award now refreshes its statistics as well as its grid. Changing which confirmations count — LoTW only, LoTW plus cards — left the whole matrix showing the previous rule's numbers, with nothing to say they were stale.",
+      "The DXCC statistics show the Challenge, and say what the two totals mean. The Challenge counts confirmed band-slots on ten bands and 60 m is not one of them — which is the whole of the gap against LoTW's figure. The Total column is entities, the last column is band-slots, and both now say so when hovered.",
+      "Deleted DXCC entities survive an import. A QSO carrying an entity the ARRL has since deleted — Malyj Vysotskij, Czechoslovakia, the German DR and the rest — was being re-stamped from cty.dat, which only knows where a callsign is TODAY: a 2004 R1MVI came back as European Russia and the credit was gone, for a place that can never be worked again. The number in the file is now left alone for those entities."
+    ],
+    "fr": [
+      "Diplômes : la matrice des bandes affiche les bandes sur lesquelles on a des contacts — pas davantage, et sans s'arrêter au 70cm. Elle listait toutes les bandes autorisées par le diplôme, si bien que le DDFM restait avec des colonnes 6m et 70cm vides, et ne pouvait pas afficher le 23cm quoi que dise le diplôme.",
+      "Amplificateurs Elecraft KPA500 et KPA1500, en série ou — pour le KPA1500 — par le réseau. Operate/standby, marche/arrêt, puissance, ROS, température, tension et courant d'alimentation, la bande, et les défauts nommés en clair plutôt qu'en code. Ils rejoignent le SPE, l'Acom et le PowerGenius, donc le couplage de plusieurs amplificateurs fonctionne aussi avec eux. NOUVEAU, ET PAS ENCORE TESTÉ SUR UN VRAI AMPLIFICATEUR : c'est écrit d'après la documentation de programmation d'Elecraft, donc merci de signaler ce que ça donne.",
+      "Les amplificateurs Elecraft suivent tout seuls la bande de la radio, sur la liaison déjà ouverte — ils ont leur propre commande de bande, donc aucun second port série n'intervient. Désactivable pour un amplificateur câblé directement à la radio.",
+      "Les cartes Light et Voyager s'affichaient barrées d'un « API KEY REQUIRED ». Carto marque désormais ses tuiles sans clé, donc les deux vues passent chez Esri, le fournisseur déjà derrière Street et Satellite. Light garde son allure ; Voyager devient une carte topographique et s'appelle Topo — ceux qui l'avaient choisie la conservent.",
+      "Ultrabeam / SteppIR en USB : le port COM se choisit à nouveau dans la liste. Le champ était de ceux où l'on peut aussi taper, et la liste ne se laissait pas sélectionner.",
+      "Une console de contrôle pour SunSDR / ExpertSDR3, en onglet et en volet ancré : puissance et puissance d'accord, gain micro, ACCORD, puissance et ROS pendant l'émission, volume, muet, squelch, NB, NR, ANF, APF en CW, AGC, filtres proposés selon le mode, RIT et XIT, verrouillage du VFO, et un S-mètre en vrais dBm. Les niveaux se règlent à la souris, à la molette, par pas ou en tapant la valeur. Elle suit la fenêtre de la radio — TCI annonce chaque changement, quel qu'en soit l'auteur.",
+      "La console Elecraft peut être ancrée comme volet de la vue principale. Elle le pouvait depuis toujours ; le réglage ne la proposait tout simplement pas.",
+      "Les alertes de spot nomment le bon mode. Un spot FT8 sur 30 m déclenchait une alerte annonçant SSB alors que la liste du cluster juste à côté affichait DATA : le moteur d'alertes avait son propre plan de bandes, plus grossier, qui appelait « phonie » tout ce qui dépassait 10,130. Les deux lisent désormais la même table, et une fréquence hors plan reste sans mode plutôt que devinée.",
+      "Diplômes : modifier un diplôme actualise désormais ses statistiques et pas seulement sa grille. Changer les confirmations qui comptent — LoTW seul, LoTW plus cartes — laissait toute la matrice afficher les chiffres de la règle précédente, sans rien pour dire qu'ils étaient périmés.",
+      "Les statistiques DXCC affichent le Challenge et disent ce que sont les deux totaux. Le Challenge compte les créneaux bande confirmés sur dix bandes, dont le 60 m ne fait pas partie — c'est là tout l'écart avec le chiffre de LoTW. La colonne Total, ce sont les entités ; la dernière, les créneaux bande ; les deux le disent au survol.",
+      "Les entités DXCC supprimées survivent à un import. Un QSO portant une entité depuis supprimée par l'ARRL — Malyj Vysotskij, la Tchécoslovaquie, la RDA et les autres — était réécrit d'après cty.dat, qui ne sait que où se trouve un indicatif AUJOURD'HUI : un R1MVI de 2004 revenait en Russie d'Europe et le crédit disparaissait, pour un endroit qu'on ne pourra plus jamais contacter. Le numéro du fichier est désormais conservé pour ces entités."
+    ]
+  },
+  {
+    "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": [
+      "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",
     "date": "",

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/src/App.tsx

@@ -78,6 +78,7 @@ import { WorldMap, LocatorMap } from '@/components/MainMap';
 import { FlexPanel } from '@/components/FlexPanel';
 import { IcomPanel } from '@/components/IcomPanel';
 import { YaesuPanel } from '@/components/YaesuPanel';
+import { TCIPanel } from '@/components/TCIPanel';
 import { ElecraftPanel } from '@/components/ElecraftPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
@@ -488,6 +489,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]);
@@ -1915,7 +1921,7 @@ export default function App() {
   // so it's loaded async on mount and re-read on profile:changed below.
   // 'none' is only ever stored for the third and fourth panes: the first two are
   // the Main view, and a layout with no panes at all is not a layout.
-  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | 'tci' | 'netcontrol' | 'decodes' | 'none';
   const [mapZoomSignal, setMapZoomSignal] = useState(0); // bump → world map auto-zooms now
   const [mainPaneLeft, setMainPaneLeft] = useState<MainPaneKind>('map1');
   const [mainPaneRight, setMainPaneRight] = useState<MainPaneKind>('map2');
@@ -1926,7 +1932,7 @@ export default function App() {
   // quarter-width map is unreadable.
   const [mainLayout4, setMainLayout4] = useState<'cols' | 'quad'>('quad');
   const loadMainPanes = useCallback(async () => {
-    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'netcontrol' || v === 'decodes';
+    const valid = (v: string): v is MainPaneKind => v === 'map1' || v === 'map2' || v === 'cluster' || v === 'worked' || v === 'flex' || v === 'recent' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || v === 'netcontrol' || v === 'decodes';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -3081,6 +3087,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 +4195,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)); }
@@ -6133,6 +6175,12 @@ export default function App() {
             <ElecraftPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
           </div>
         );
+      case 'tci':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <TCIPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+          </div>
+        );
       case 'icom':
         return (
           <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
@@ -7051,6 +7099,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,
@@ -7410,6 +7459,7 @@ export default function App() {
               {catState.backend === 'icom' && <TabsTrigger value="icom">Icom Console</TabsTrigger>}
               {catState.backend === 'yaesu' && <TabsTrigger value="yaesu">Yaesu Console</TabsTrigger>}
             {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && <TabsTrigger value="elecraft">{t('k3.console')}</TabsTrigger>}
+            {catState.backend === 'tci' && <TabsTrigger value="tci">{t('tcip.console')}</TabsTrigger>}
               {statsTabOpen && (
                 <TabsTrigger value="stats" className="gap-1.5">
                   {t('stats.tab')}
@@ -8098,6 +8148,15 @@ export default function App() {
               </TabsContent>
             )}
 
+            {/* The SunSDR console. Everything on it is state the radio pushes
+                over TCI unasked, so unlike the serial consoles it costs nothing
+                to keep open. */}
+            {catState.backend === 'tci' && (
+              <TabsContent value="tci" className="flex-1 min-h-0 p-0">
+                <TCIPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
+              </TabsContent>
+            )}
+
             {catState.backend === 'icom' && (
               <TabsContent value="icom" className="flex-1 min-h-0 p-0">
                 <IcomPanel isNetwork={catBackend === 'icom-net'} onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} />
@@ -8488,28 +8547,16 @@ 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'}
+          elecraftAvailable={catState.backend === 'elecraft' || catState.backend === 'kenwood'}
+          tciAvailable={catState.backend === 'tci'}
         />
       )}
 

frontend/src/components/AmpCard.tsx

@@ -47,7 +47,7 @@ function powerLevelLabel(pl?: string): string {
   }
 }
 
-type Amp = { id: string; name: string; type?: string; spe?: any; acom?: any; pgxl?: any };
+type Amp = { id: string; name: string; type?: string; spe?: any; acom?: any; kpa?: any; pgxl?: any };
 
 export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string, v?: any) => string }) {
   // Peak-hold so the jittery VITA-49 meters read steadily (own ref per card).
@@ -64,6 +64,7 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
 
   const isSPE = !!amp.spe;
   const isACOM = !!amp.acom;
+  const isKPA = !!amp.kpa;
 
   if (isSPE) {
     const spe = amp.spe;
@@ -127,7 +128,7 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
   if (isACOM) {
     const acom = amp.acom;
     return (
-      <Card icon={Flame} ckey="amplifier" title={`${t('flxp.amplifier')} · ${amp.name || `ACOM${acom.model ? ' ' + acom.model : ''}`}`} accent="#ea580c">
+      <Card icon={Flame} ckey="amplifier" title={`${t('flxp.amplifier')} · ${amp.name || `Acom${acom.model ? ' ' + acom.model : ''}`}`} accent="#ea580c">
         <div className="flex items-center gap-3 flex-wrap">
           <button type="button" disabled={!acom.connected}
             onClick={() => AmpOperate(amp.id, !acom.operate).catch(() => {})}
@@ -168,6 +169,53 @@ export function AmpCard({ amp, flex, t }: { amp: Amp; flex: any; t: (k: string,
     );
   }
 
+  if (isKPA) {
+    const kpa = amp.kpa;
+    return (
+      <Card icon={Flame} ckey="amplifier" title={`${t('flxp.amplifier')} · ${amp.name || kpa.model || 'Elecraft'}`} accent="#ea580c">
+        <div className="flex items-center gap-3 flex-wrap">
+          <button type="button" disabled={!kpa.connected}
+            onClick={() => AmpOperate(amp.id, !kpa.operate).catch(() => {})}
+            title={kpa.fault_text ? t('flxp.kpaClearsFault') : undefined}
+            className={cn('px-4 py-2 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+              kpa.operate ? 'bg-warning text-warning-foreground border-warning shadow-[0_0_14px] shadow-warning/50' : 'bg-card text-warning border-warning hover:bg-warning-muted')}>
+            {kpa.operate ? 'OPERATE' : 'STANDBY'}
+          </button>
+          {/* The amplifier answers while its main supplies are off — a sleeping
+              microcontroller stays awake for exactly that — so ON is offered
+              over the network as well, unlike the SPE and Acom. */}
+          <div className="inline-flex rounded-lg overflow-hidden border-2 border-success/70">
+            <button type="button" disabled={!kpa.connected}
+              onClick={() => AmpPower(amp.id, true).catch(() => {})}
+              className="px-3 py-2 text-sm font-bold bg-card text-success hover:bg-success/15 disabled:opacity-30">ON</button>
+            <button type="button" disabled={!kpa.connected}
+              onClick={() => AmpPower(amp.id, false).catch(() => {})}
+              className="px-3 py-2 text-sm font-bold bg-card text-danger border-l-2 border-success/70 hover:bg-danger/15 disabled:opacity-30">OFF</button>
+          </div>
+          <span className={cn('inline-flex items-center gap-1.5 text-sm', kpa.connected ? 'text-muted-foreground' : 'text-danger')}>
+            <span className={cn('size-2 rounded-full', kpa.connected ? 'bg-success' : 'bg-danger')} />
+            {kpa.connected ? (kpa.tuning ? t('flxp.kpaTuning') : (kpa.power_on ? 'ON' : 'OFF')) : t('flxp.acomOffline')}
+          </span>
+          {kpa.connected && (
+            <span className="text-sm font-mono text-muted-foreground tabular-nums">
+              {kpa.band ? `${kpa.band} · ` : ''}{kpa.fwd_w}W · SWR {Number(kpa.swr ?? 0).toFixed(1)} · {kpa.temp_c}°C · {kpa.volt_v}V {kpa.cur_a}A
+            </span>
+          )}
+          <div className="flex-1" />
+          {kpa.fault_text && (
+            <span className="px-2 py-1 rounded bg-danger-muted text-danger-muted-foreground text-xs font-bold">⚠ {kpa.fault_text}</span>
+          )}
+        </div>
+        {kpa.connected && (
+          <MeterBar label={t('flxp.outputPower')} value={Number(kpa.fwd_w) || 0} unit="W"
+            lo={0} hi={String(kpa.model).includes('500') ? 500 : 1500}
+            display={`${Number(kpa.fwd_w) || 0} W`}
+            segColor={(f) => (f > 0.9 ? '#dc2626' : f > 0.75 ? '#f59e0b' : '#ea580c')} />
+        )}
+      </Card>
+    );
+  }
+
   // PowerGenius XL — OPERATE + meters ride on the Flex; fan mode on the GSCP link.
   const pg = amp.pgxl || {};
   const viaFlex = !!flex?.amp_available;

frontend/src/components/AmpWidget.tsx

@@ -15,7 +15,7 @@ import { AmpOperate, AmpPower, AmpPowerLevel, AmpFanMode, FlexAmpOperate } from
 // With several amplifiers configured the caller passes a selection ("all" or an
 // amp id) chosen from the toolbar icon's dropdown.
 
-type Amp = { id: string; name: string; type?: string; spe?: any; acom?: any; pgxl?: any };
+type Amp = { id: string; name: string; type?: string; spe?: any; acom?: any; kpa?: any; pgxl?: any };
 
 // Full-scale watts for the output bar, from the model string.
 function maxW(model?: string, fallback = 1300): number {
@@ -92,27 +92,39 @@ function OperateButton({ operate, disabled, onClick, t }: {
 function AmpBlock({ amp, flex, showName, t }: {
   amp: Amp; flex: any; showName: boolean; t: (k: string, v?: any) => string;
 }) {
-  const spe = amp.spe, acom = amp.acom;
+  const spe = amp.spe, acom = amp.acom, kpaAmp = amp.kpa;
   const hold = usePeakHold();
 
-  if (spe || acom) {
+  // One block for the three amplifiers OpsLog drives over its own link. They
-    const s = spe || acom;
+  // report the same handful of things under different names, so the differences
+  // are named here rather than spread through the markup.
+  if (spe || acom || kpaAmp) {
+    const s = spe || acom || kpaAmp;
     // The amp reports zero watts on receive, so its TX flag clears the meter as
     // soon as the operator lets go — and the radio's own flag, when we have one,
     // gets there first (the amp is polled on its own slower cycle).
     const txing = typeof flex?.transmitting === 'boolean' ? flex.transmitting : s.tx !== false;
     const w = hold('w', Number(spe ? s.output_w : s.fwd_w) || 0, txing);
     const swr = Number(spe ? s.swr_ant : s.swr) || 0;
-    const hi = spe ? maxW(s.model) : (Number(s.max_w) || 800);
+    // The full-scale mark. A KPA500 reading against a 1500 W scale would look
+    // idle at full output, so the model decides it.
+    const hi = spe ? maxW(s.model)
+      : kpaAmp ? (String(s.model).includes('500') ? 500 : 1500)
+      : (Number(s.max_w) || 800);
     // Power ON drives the remote-on control lines, so it stays available while
     // the amplifier is off and reporting nothing — but only over a serial link.
-    const canPowerOn = spe ? (s.connected || s.transport === 'serial') : (s.port_open && s.transport === 'serial');
+    // A KPA answers ^ON while its main supplies are off — the sleeping
+    // microcontroller stays awake for exactly that — so power-on is available
+    // whenever the link itself is up, over serial and over the network alike.
+    const canPowerOn = spe ? (s.connected || s.transport === 'serial')
+      : kpaAmp ? !!s.connected
+      : (s.port_open && s.transport === 'serial');
     return (
       <div className="h-full flex flex-col gap-1.5">
         {showName && (
           <div className="flex items-center gap-1.5">
             <span className={cn('size-1.5 rounded-full shrink-0', s.connected ? 'bg-success shadow-[0_0_6px_rgba(16,185,129,0.8)]' : 'bg-danger')} />
-            <span className="text-[10px] font-bold uppercase tracking-wider truncate">{amp.name || (spe ? 'SPE' : 'ACOM')}</span>
+            <span className="text-[10px] font-bold uppercase tracking-wider truncate">{amp.name || (spe ? 'SPE' : kpaAmp ? (s.model || 'KPA') : 'Acom')}</span>
             {s.connected && s.band && <span className="ml-auto text-[9px] text-muted-foreground shrink-0">{s.band}</span>}
           </div>
         )}
@@ -155,11 +167,17 @@ function AmpBlock({ amp, flex, showName, t }: {
         ) : (
           <div className="text-[10px] text-center text-muted-foreground italic py-1">{t('ampw.offline')}</div>
         )}
-        {(s.warnings || s.alarms || s.err_text) && (
+        {(s.warnings || s.alarms || s.err_text || s.fault_text) && (
           <div className="rounded-md border border-danger-border bg-danger-muted text-danger-muted-foreground text-[9px] px-1.5 py-0.5 text-center break-words">
-            {s.err_text || `${s.warnings || ''} ${s.alarms || ''}`.trim()}
+            {s.fault_text || s.err_text || `${s.warnings || ''} ${s.alarms || ''}`.trim()}
           </div>
         )}
+        {/* Said where the fault is read, because it is the way out of it: on a
+            KPA, going to OPERATE clears the current fault — everything except
+            temperature, which clears by cooling. */}
+        {kpaAmp && s.fault_text && (
+          <div className="text-[9px] text-center text-muted-foreground">{t('ampw.kpaClear')}</div>
+        )}
         <PowerMeter label={t('flxp.outputPower')} watts={s.connected ? w : 0} maxWatts={hi} />
       </div>
     );

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/AwardsPanel.tsx

@@ -29,7 +29,32 @@ type AwardResult = {
 type AwardStatRow = { label: string; cells: number[]; total: number; grand_total: number };
 type AwardStats = { code: string; bands: string[]; rows: AwardStatRow[] };
 
-// Fixed band columns for the matrix view (Log4OM-style).
+// Every band the matrix can show, in the order they belong in.
+//
+// The columns are the intersection of this with what the award covers, so a
+// band missing HERE cannot appear at all whatever the award says — which is how
+// DDFM, a French award worked well into the microwaves, ended at 70cm with no
+// 23cm column and no way to ask for one.
+//
+// Mirrors bandOrder in internal/award — the same list in frequency order. The
+// two are kept apart because they answer different questions (that one sorts an
+// award's own band counts, this one lays out columns), but a band added to one
+// belongs in the other.
+// The DXCC Challenge counts one point per CONFIRMED entity per band, over ten
+// bands — and 60 m is NOT one of them. That is the whole of the gap an operator
+// notices between OpsLog and LoTW: 3229 here against 3004 there, and 224 of the
+// difference is the 60 m column.
+//
+// Worked out from the confirmed row rather than asked of the backend, because
+// that row IS the answer: the Challenge is its sum over these ten bands.
+const CHALLENGE_BANDS = ['160m', '80m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m'];
+
+const ALL_BANDS = ['2190m','630m','160m','80m','60m','40m','30m','20m','17m','15m','12m','10m',
+  '6m','4m','2m','1.25m','70cm','33cm','23cm','13cm','9cm','6cm','3cm','1.25cm','6mm','4mm','2.5mm','2mm','1mm'];
+
+// What to show when there is nothing to narrow it down: an award with no band
+// list and no contacts yet. The classic set — the whole of ALL_BANDS would be
+// twenty-nine columns of mostly nothing.
 const GRID_BANDS = ['160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','2m','70cm'];
 
 // Per-band status for a reference, highest first.
@@ -180,26 +205,46 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
   useEffect(() => { if (selected) compute(selected); /* eslint-disable-next-line react-hooks/exhaustive-deps */ }, [modeFilter]);
 
   // Bands relevant to the selected award, used by BOTH the grid and the stats
-  // matrix so neither is padded with bands the award doesn't use. Rule: the
+  // matrix so neither is padded with bands nothing was worked on. Rule: the
-  // award's explicit valid_bands if it has any (e.g. WAPC = 40/20/15/10m); else
+  // bands this operator HAS contacts on for this award; failing that, the
-  // the bands the operator actually has contacts on (so DXCC, which has no band
+  // award's own list of permitted bands. Empty set = no basis at all → callers
-  // restriction, shows 160m–6m instead of empty VHF/UHF columns). Empty set =
+  // fall back to the classic columns.
-  // no basis yet → callers fall back to all bands.
   const awardBands = useMemo(() => {
-    const vb = (awardList.find((a) => a.code === selected)?.bands ?? []).map((b) => b.toLowerCase());
+    // The bands with CONTACTS on them come first, whatever the award declares.
-    if (vb.length > 0) return new Set(vb);
+    //
-    const worked = (current?.bands ?? [])
+    // It used to take the declared list when there was one, which put up a
+    // column for every band the award permits — DDFM allows 6m and 70cm, so
+    // both stood there empty on a station that has never worked a French
+    // department on either. An always-blank column reads as a gap in the log
+    // rather than as a band the operator never tried.
+    const worked = new Set((current?.bands ?? [])
       .filter((b) => (b.worked ?? 0) > 0)
-      .map((b) => String(b.band).toLowerCase());
+      .map((b) => String(b.band).toLowerCase()));
-    return new Set(worked);
+    if (worked.size > 0) return worked;
+    // Nothing worked yet: the award's own list is the honest answer — it says
+    // what this award is played on, which is the only thing there is to show.
+    return new Set((awardList.find((a) => a.code === selected)?.bands ?? []).map((b) => b.toLowerCase()));
   }, [awardList, selected, current]);
 
   const gridBands = useMemo(() => {
     if (awardBands.size === 0) return GRID_BANDS;
-    const filtered = GRID_BANDS.filter((b) => awardBands.has(b));
+    // Filtered from ALL_BANDS, so a band the award covers gets its column even
+    // when it is one the classic set never listed.
+    const filtered = ALL_BANDS.filter((b) => awardBands.has(b));
     return filtered.length ? filtered : GRID_BANDS;
   }, [awardBands]);
 
+  const challenge = useMemo(() => {
+    if (!stats || selected.toUpperCase() !== 'DXCC') return null;
+    const row = stats.rows.find((r) => r.label === 'CONFIRMED');
+    if (!row) return null;
+    let total = 0;
+    stats.bands.forEach((b, i) => {
+      if (CHALLENGE_BANDS.includes(String(b).toLowerCase())) total += Number(row.cells[i]) || 0;
+    });
+    return total;
+  }, [stats, selected]);
+
   // Stats rows to show: drop the mode-category rows (CW / DIGITAL / PHONE) the
   // award doesn't cover. The "ALL" rows (no suffix) always show; a category row
   // shows only when the award has no emission restriction or lists that emission.
@@ -319,7 +364,13 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
             {t('awp.rescan')}
           </Button>
         </div>
-        <AwardEditor open={editing} onClose={() => setEditing(false)} onSaved={() => { setByCode({}); loadList(); onAwardsChanged?.(); }} />
+        {/* setRescanTick as well as setByCode. The grid was refreshed on save
+            and the statistics matrix was not, so changing which confirmations
+            count — LoTW only, LoTW plus cards — left the whole table showing
+            the previous rule's numbers with nothing to say they were stale.
+            That is how a setting comes to look as though it does nothing. */}
+        <AwardEditor open={editing} onClose={() => setEditing(false)}
+          onSaved={() => { setByCode({}); setRescanTick((t) => t + 1); loadList(); onAwardsChanged?.(); }} />
         {/* Quick selector — scales when there are many awards. */}
         {awardList.length > 0 && (
           <div className="px-2 py-2 border-b border-border/40">
@@ -473,8 +524,8 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                       <tr className="bg-card">
                         <th className="sticky left-0 z-20 bg-card text-left py-1.5 pr-3 font-medium border-b border-border">{t('awp.statistic')}</th>
                         {statsBandIdx.map((i) => <th key={stats.bands[i]} className="py-1.5 px-1 font-mono font-medium border-b border-border text-center w-11">{stats.bands[i]}</th>)}
-                        <th className="py-1.5 px-2 font-medium border-b border-border text-center">{t('awp.total')}</th>
+                        <th className="py-1.5 px-2 font-medium border-b border-border text-center" title={t('awp.totalHint')}>{t('awp.total')}</th>
-                        <th className="py-1.5 px-2 font-medium border-b border-border text-center">{t('awp.grand')}</th>
+                        <th className="py-1.5 px-2 font-medium border-b border-border text-center" title={t('awp.grandHint')}>{t('awp.grand')}</th>
                       </tr>
                     </thead>
                     <tbody>
@@ -493,6 +544,19 @@ export function AwardsPanel({ onEditQSO, onAwardsChanged, onPaperQSL }: {
                         );
                       })}
                     </tbody>
+                    {challenge !== null && (
+                      <tfoot>
+                        <tr>
+                          <td className="sticky left-0 bg-card py-1.5 pr-3 font-semibold whitespace-nowrap" title={t('awp.challengeHint')}>
+                            {t('awp.challenge')}
+                          </td>
+                          <td colSpan={statsBandIdx.length} className="py-1.5 text-[11px] text-muted-foreground">
+                            {t('awp.challengeBands')}
+                          </td>
+                          <td className="text-center py-1.5 px-2 font-mono font-bold text-success" colSpan={2}>{challenge}</td>
+                        </tr>
+                      </tfoot>
+                    )}
                   </table>
                 )}
               </div>

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/IcomPanel.tsx

@@ -14,6 +14,8 @@ import {
 import { cn } from '@/lib/utils';
 import { useI18n } from '@/lib/i18n';
 import { sMeterRST } from '@/lib/rst';
+import { MeterBar } from '@/components/MeterBar';
+import { ShiftRow } from '@/components/ShiftRow';
 
 type IcomState = {
   available: boolean; model?: string; mode?: string;
@@ -248,39 +250,6 @@ function Meter({ label, value, accent, scale, onClick, title }: { label: string;
   return <div className="flex items-center gap-2">{body}</div>;
 }
 
-// ShiftRow — a RIT / ΔTX offset control: on/off chip + a wheel-adjustable signed
-// offset (±10 Hz per notch or per ± button) + a clear (0) button.
-function ShiftRow({ label, on, hz, accent, onToggle, onDelta, onClear }: {
-  label: string; on: boolean; hz: number; accent: string;
-  onToggle: () => void; onDelta: (d: number) => void; onClear: () => void;
-}) {
-  const ref = useRef<HTMLDivElement>(null);
-  const cb = useRef(onDelta); cb.current = onDelta;
-  useEffect(() => {
-    const el = ref.current;
-    if (!el) return;
-    const onWheel = (e: WheelEvent) => { e.preventDefault(); cb.current(e.deltaY < 0 ? 10 : -10); };
-    el.addEventListener('wheel', onWheel, { passive: false });
-    return () => el.removeEventListener('wheel', onWheel);
-  }, []);
-  return (
-    <div className="flex items-center gap-2">
-      <Chip on={on} onClick={onToggle} label={label} />
-      <div ref={ref} title="Wheel / ± to shift"
-        className={cn('flex-1 flex items-center justify-between rounded-md border px-1 py-0.5 select-none cursor-ns-resize',
-          on ? 'border-border bg-muted/40' : 'border-border/60 bg-muted/20 opacity-60')}>
-        <button type="button" onClick={() => onDelta(-10)} className="px-2 text-sm font-bold text-muted-foreground hover:text-foreground">−</button>
-        <span className="text-sm font-mono font-bold tabular-nums" style={{ color: on ? accent : undefined }}>
-          {hz > 0 ? '+' : hz < 0 ? '−' : ''}{Math.abs(hz)} Hz
-        </span>
-        <button type="button" onClick={() => onDelta(10)} className="px-2 text-sm font-bold text-muted-foreground hover:text-foreground">+</button>
-      </div>
-      <button type="button" onClick={onClear}
-        className="w-8 shrink-0 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted">0</button>
-    </div>
-  );
-}
-
 // sParts turns the raw 0-100 S-meter into S-unit + dB-over-S9 (S9 ≈ 47% on the
 // CI-V 0-255 scale, +60 dB near full scale). Used for both the display label and
 // the RST-tx value on click.
@@ -797,10 +766,10 @@ export function IcomPanel({ onReportRST, isNetwork = false }: { onReportRST?: (r
       <Card icon={SlidersHorizontal} title={t('icmp.clarifiers')} accent="#8b5cf6">
         <ShiftRow label="RIT" accent="#8b5cf6" on={st.rit_on} hz={st.rit_hz}
           onToggle={() => set({ rit_on: !st.rit_on }, () => IcomSetRITOn(!st.rit_on))}
-          onDelta={(d) => setRit(st.rit_hz + d)} onClear={() => setRit(0)} />
+          onSet={setRit} />
         <ShiftRow label="ΔTX" accent="#f59e0b" on={st.xit_on} hz={st.rit_hz}
           onToggle={() => set({ xit_on: !st.xit_on }, () => IcomSetXITOn(!st.xit_on))}
-          onDelta={(d) => setRit(st.rit_hz + d)} onClear={() => setRit(0)} />
+          onSet={setRit} />
         <p className="text-[11px] text-muted-foreground">{t('icmp.ritHint')}</p>
       </Card>
 

frontend/src/components/LevelRow.tsx

@@ -0,0 +1,72 @@
+import { useState } from 'react';
+import { cn } from '@/lib/utils';
+import { WheelRange } from '@/components/WheelRange';
+
+// LevelRow — a named level with a slider, a value you can type into, and ±.
+//
+// Shared, like ShiftRow, and for the same complaint: the consoles each drew
+// their levels their own way. This is the wide shape — one row per level, the
+// slider taking the width it needs — rather than two half-width sliders side by
+// side, which is what "c'est laid et elles sont toutes petites" was about.
+//
+// Four ways to move it, so nobody has to learn ours: drag, wheel over the
+// track, ± for one step, or click the number and type. Typing matters for the
+// levels TCI reports in real units — a squelch at -95 dBm is a value an
+// operator knows, not a position to hunt for with a mouse.
+export function LevelRow({
+  label, value, min = 0, max = 100, step = 1, unit = '', accent, disabled, onSet,
+}: {
+  label: string;
+  value: number;
+  min?: number;
+  max?: number;
+  step?: number;
+  unit?: string;
+  accent?: string;
+  disabled?: boolean;
+  onSet: (v: number) => void;
+}) {
+  const [editing, setEditing] = useState<string | null>(null);
+  const clamp = (v: number) => Math.max(min, Math.min(max, v));
+  const commit = (raw: string) => {
+    setEditing(null);
+    const v = parseInt(raw.replace(/[^0-9+-]/g, ''), 10);
+    if (!Number.isNaN(v)) onSet(clamp(v));
+  };
+  return (
+    <div className="flex items-center gap-3">
+      <span className="w-24 shrink-0 text-[11px] font-bold uppercase tracking-wider text-muted-foreground">
+        {label}
+      </span>
+      <WheelRange
+        min={min} max={max} step={step} value={value} disabled={disabled} accent={accent}
+        onChange={onSet}
+        className="h-2.5 flex-1 [&::-webkit-slider-thumb]:size-4"
+      />
+      <div className={cn('flex items-center gap-0.5 shrink-0', disabled && 'opacity-40')}>
+        <button type="button" disabled={disabled} onClick={() => onSet(clamp(value - step))}
+          className="px-1.5 text-sm font-bold text-muted-foreground hover:text-foreground disabled:opacity-40">−</button>
+        {editing !== null ? (
+          <input
+            autoFocus
+            value={editing}
+            onChange={(e) => setEditing(e.target.value)}
+            onBlur={(e) => commit(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter') commit((e.target as HTMLInputElement).value);
+              else if (e.key === 'Escape') setEditing(null);
+            }}
+            className="w-14 rounded border border-border bg-background px-1 text-right text-xs font-mono tabular-nums outline-none"
+          />
+        ) : (
+          <button type="button" disabled={disabled} onClick={() => setEditing(String(value))}
+            className="w-14 text-right text-xs font-mono tabular-nums hover:text-primary disabled:cursor-default">
+            {value}{unit}
+          </button>
+        )}
+        <button type="button" disabled={disabled} onClick={() => onSet(clamp(value + step))}
+          className="px-1.5 text-sm font-bold text-muted-foreground hover:text-foreground disabled:opacity-40">+</button>
+      </div>
+    </div>
+  );
+}

frontend/src/components/MainMap.tsx

@@ -42,8 +42,18 @@ function unwrapLon(ring: [number, number][]): [number, number][] {
   return out;
 }
 
-const CARTO_LIGHT = 'https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png';
+// CARTO IS GONE, and it went the same way OpenStreetMap did.
-const CARTO_ATTR = '© OpenStreetMap © CARTO';
+//
+// Their key-free basemaps now serve tiles stamped "API KEY REQUIRED" across
+// the middle of the map — reported by an operator whose Light and Voyager views
+// came up watermarked. They still answer 200 with a real image, which is why
+// nothing here could detect it: the map looks like it is working and simply
+// says otherwise in large grey letters.
+//
+// So both are replaced by Esri layers, the same provider already behind Street
+// and Satellite. That is deliberate: a second key-free provider is a second
+// chance to be cut off, and this one has already been serving the other two
+// views for as long as OpsLog has had a map.
 
 // NOT tile.openstreetmap.org. Those are OpenStreetMap's VOLUNTEER-run servers,
 // and their usage policy does not cover a desktop application handed to an
@@ -55,17 +65,33 @@ const CARTO_ATTR = '© OpenStreetMap © CARTO';
 // still credits OpenStreetMap) and Esri. Anything added here later must be
 // checked the same way — a free tile URL is not the same thing as a tile URL we
 // are allowed to ship.
-const ESRI_STREET = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}';
+const ESRI = 'https://server.arcgisonline.com/ArcGIS/rest/services';
+const ESRI_STREET = ESRI + '/World_Street_Map/MapServer/tile/{z}/{y}/{x}';
 const ESRI_STREET_ATTR = 'Tiles © Esri — Source: Esri, HERE, Garmin, © OpenStreetMap contributors';
 
+// The plain background the old Carto "Light" was: a pale canvas that lets the
+// paths and the spots carry the colour. Its names come on a separate
+// transparent layer, the same arrangement the satellite view already uses.
+const ESRI_LIGHT = ESRI + '/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}';
+const ESRI_LIGHT_LABELS = ESRI + '/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}';
+const ESRI_LIGHT_ATTR = 'Tiles © Esri — Esri, DeLorme, NAVTEQ';
+
 // Selectable basemaps for the world (great-circle) map. All key-free and all
 // LABELLED (country/continent names). `labelsUrl` adds a transparent place-name
 // overlay on top of an imagery basemap (so satellite keeps its names too).
 export type BasemapKey = 'light' | 'voyager' | 'street' | 'satellite';
-export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string }> = {
+// maxNativeZoom is where a layer RUNS OUT of tiles. Leaflet then upscales the
-  light:     { label: 'Light',     url: CARTO_LIGHT, attr: CARTO_ATTR, subdomains: 'abcd' },
+// last real one instead of asking for a level that does not exist, which is the
-  voyager:   { label: 'Voyager',   url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png',
+// difference between a slightly soft map and a blank grey square: the light
-               attr: CARTO_ATTR, subdomains: 'abcd' },
+// canvas stops at 16 where the imagery and the topo go on to 19.
+export const BASEMAPS: Record<BasemapKey, { label: string; url: string; attr: string; subdomains?: string; labelsUrl?: string; maxNativeZoom?: number }> = {
+  light:     { label: 'Light',     url: ESRI_LIGHT, attr: ESRI_LIGHT_ATTR, labelsUrl: ESRI_LIGHT_LABELS, maxNativeZoom: 16 },
+  // The key is still "voyager" so that everyone who chose it keeps their view
+  // rather than being silently moved to another one. What it draws is Esri's
+  // topographic map: terrain under the labels, which is what made Voyager worth
+  // choosing over the plain canvas.
+  voyager:   { label: 'Topo',      url: ESRI + '/World_Topo_Map/MapServer/tile/{z}/{y}/{x}',
+               attr: 'Tiles &copy; Esri — Esri, HERE, Garmin, USGS, NGA, &copy; OpenStreetMap contributors' },
   street:    { label: 'Street',    url: ESRI_STREET, attr: ESRI_STREET_ATTR },
   satellite: { label: 'Satellite', url: 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
                attr: 'Tiles &copy; Esri — Source: Esri, Maxar, Earthstar Geographics',
@@ -100,7 +126,8 @@ export function addBasemap(
   if (labels.current) { m.removeLayer(labels.current); labels.current = null; }
   const bm = BASEMAPS[key];
   const tileOpts: L.TileLayerOptions = {
-    maxZoom: 19, updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
+    maxZoom: 19, maxNativeZoom: bm.maxNativeZoom ?? 19,
+    updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
     noWrap: !!opts?.noWrap,
     ...(opts?.bounds ? { bounds: opts.bounds } : {}),
   };
@@ -448,8 +475,12 @@ export function LocatorMap({ toGrid, toLabel }: LocatorProps) {
       // single ring of buffer tiles. Requesting tiles as fast as the pointer
       // moves is what gets an app blocked, and the next provider is under no
       // more obligation to tolerate it than the last one was.
-      L.tileLayer(CARTO_LIGHT, {
+      L.tileLayer(ESRI_LIGHT, {
-        attribution: CARTO_ATTR, subdomains: 'abcd', maxZoom: 19,
+        attribution: ESRI_LIGHT_ATTR, maxZoom: 19, maxNativeZoom: 16,
+        updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
+      }).addTo(m);
+      L.tileLayer(ESRI_LIGHT_LABELS, {
+        maxZoom: 19, maxNativeZoom: 16,
         updateWhenIdle: true, updateWhenZooming: false, keepBuffer: 1,
       }).addTo(m);
       locatorOverlay.current = L.layerGroup().addTo(m);

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,
@@ -175,6 +175,13 @@ 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
+  elecraftAvailable?: boolean; // CAT backend is Elecraft/Kenwood → the K3/K4 console
+  tciAvailable?: boolean; // CAT backend is TCI → the SunSDR console
+  // 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 +207,7 @@ type SectionId =
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
+  | 'lists-satellites'
   | 'cluster'
   | 'backup'
   | 'database'
@@ -310,6 +318,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 +348,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 +370,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',
@@ -897,9 +907,10 @@ function AmpStatusCard({ id }: { id: string }) {
     const t = window.setInterval(tick, 1000);
     return () => { alive = false; window.clearInterval(t); };
   }, [id]);
-  const st: any = amp?.spe ?? amp?.acom ?? amp?.pgxl ?? { connected: false };
+  const st: any = amp?.spe ?? amp?.acom ?? amp?.kpa ?? amp?.pgxl ?? { connected: false };
   const isSPE = !!amp?.spe;
   const isACOM = !!amp?.acom;
+  const isKPA = !!amp?.kpa;
   const operate = !!st.operate;
   return (
     <div className="rounded-md border border-border p-3 space-y-2 text-xs max-w-xl">
@@ -940,7 +951,23 @@ function AmpStatusCard({ id }: { id: string }) {
           {st.err_text && <div className="col-span-4 text-warning">⚠ {st.err_text} ({st.err_code})</div>}
         </div>
       )}
-      {st.connected && !isSPE && !isACOM && (
+      {st.connected && isKPA && (
+        <div className="grid grid-cols-4 gap-x-3 gap-y-1 font-mono text-[11px]">
+          <div>{st.power_on ? 'ON' : 'OFF'}</div>
+          <div>Band {st.band || '—'}</div>
+          <div>{st.fwd_w} W</div>
+          <div>SWR {Number(st.swr ?? 0).toFixed(1)}</div>
+          <div>{st.volt_v} V</div>
+          <div>{st.cur_a} A</div>
+          <div>{st.temp_c}°C</div>
+          <div>{st.tuning ? 'TUNING' : ''}</div>
+          {/* A fault has already put the amplifier in standby by itself, so it
+              is the one thing worth the width — and OPERATE is the way out of
+              it, which the button above already is. */}
+          {st.fault_text && <div className="col-span-4 text-warning">⚠ {st.fault_text}</div>}
+        </div>
+      )}
+      {st.connected && !isSPE && !isACOM && !isKPA && (
         <div className="grid grid-cols-3 gap-x-3 gap-y-1 font-mono text-[11px]">
           <div>{st.state || ''}</div>
           <div>Fan {st.fan_mode || '—'}</div>
@@ -1060,7 +1087,7 @@ function RelayAutoPanel() {
 // profile-prefixed). Self-contained so it owns its async-loaded state.
 const MAIN_PANE_VALUES = ['map1', 'map2', 'cluster', 'worked', 'recent', 'netcontrol', 'decodes'];
 const PANE_NONE = 'none';
-function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable }: { onChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean }) {
+function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable, elecraftAvailable, tciAvailable }: { onChanged?: (side: 'left' | 'right' | 'p3' | 'p4' | 'layout', value: string) => void; flexAvailable?: boolean; icomAvailable?: boolean; yaesuAvailable?: boolean; elecraftAvailable?: boolean; tciAvailable?: boolean }) {
   const { t } = useI18n();
   const [panes, setPanes] = useState<Record<string, string>>({ left: 'map1', right: 'map2', p3: PANE_NONE, p4: PANE_NONE });
   const [layout, setLayout] = useState('quad');
@@ -1070,11 +1097,16 @@ function MainViewPanes({ onChanged, flexAvailable, icomAvailable, yaesuAvailable
     ...(flexAvailable ? ['flex'] : []),
     ...(icomAvailable ? ['icom'] : []),
     ...(yaesuAvailable ? ['yaesu'] : []),
+    // The Elecraft console could be docked from the start — App has always had
+    // the pane — but it was never offered here, so the only way to reach it was
+    // the tab. Listed with the others now.
+    ...(elecraftAvailable ? ['elecraft'] : []),
+    ...(tciAvailable ? ['tci'] : []),
   ].map((value) => ({ value, label: t(`settings.pane.${value}`) }))
     .sort((a, b) => a.label.localeCompare(b.label));
   const KEYS: Record<string, string> = { left: 'mainPaneLeft', right: 'mainPaneRight', p3: 'mainPane3', p4: 'mainPane4' };
   useEffect(() => {
-    const valid = (v: string) => v === 'flex' || v === 'icom' || v === 'yaesu' || MAIN_PANE_VALUES.includes(v);
+    const valid = (v: string) => v === 'flex' || v === 'icom' || v === 'yaesu' || v === 'elecraft' || v === 'tci' || MAIN_PANE_VALUES.includes(v);
     Promise.all([
       ...Object.values(KEYS).map((k) => GetUIPref(k).catch(() => '')),
       GetUIPref('mainPaneLayout').catch(() => ''),
@@ -1476,7 +1508,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, elecraftAvailable, tciAvailable, onEditQSO }: Props) {
   const { t } = useI18n();
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
@@ -1505,7 +1589,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 +1598,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 +1646,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 +1963,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); }
   };
 
@@ -1943,6 +2064,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [spotTTL, setSpotTTL] = useState(0);
   const [spotTTLText, setSpotTTLText] = useState('0');
   const [spotMaxText, setSpotMaxText] = useState('1000');
+  // 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.
+
+
+
+  // Whether the QSO recorder takes its audio from the radio's own stream.
   const [gridStat, setGridStat] = useState<any>(null);
   const [pskrStatus, setPskrStatus] = useState<any>(null);
   const saveBandOpen = async (next: any) => {
@@ -1958,14 +2086,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[]>([]);
@@ -2278,6 +2414,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) {
@@ -2872,6 +3013,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()));
@@ -3019,24 +3194,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>
@@ -3163,7 +3354,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')}
@@ -3172,8 +3363,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')}
@@ -3181,6 +3372,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">
@@ -3202,14 +3398,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')}
@@ -3606,23 +3807,25 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <div className="grid grid-cols-3 gap-3">
               <div className="space-y-1 col-span-2">
                 <Label>{t('hw.motorCom')}{!isSteppir && <span className="ml-1.5 font-normal text-muted-foreground">{t('hw.motorComUb')}</span>}</Label>
-                {/* A list AND a text field, which is why this is a Combobox and
+                {/* THE SAME Select every other serial device uses.
-                    not the Select the other serial devices use: the port for a
+                    This was a Combobox — a list you could also type into — so
-                    USB adapter that is currently unplugged does not appear in
+                    that the port of an adapter currently unplugged could still
-                    the list, and refusing to accept it typed means the antenna
+                    be configured. In practice the list could not be picked from
-                    cannot be configured until the adapter is in. The detected
+                    at all, which is a worse failure than the one it was avoiding:
-                    ports are offered; anything else is still accepted. */}
+                    the port an operator wants is nearly always one that is
+                    plugged in and detected. A configured port that has since
+                    gone missing is added to the list so it stays selected and
+                    visible rather than silently disappearing. */}
                 <div className="flex items-center gap-1">
-                  <Combobox
+                  <Select value={ultrabeam.com || undefined}
-                    value={ultrabeam.com ?? ''}
+                    onValueChange={(v) => setUltrabeam((s) => ({ ...s, com: v }))}>
-                    options={wkPorts}
+                    <SelectTrigger className="h-9 font-mono flex-1"><SelectValue placeholder="COM3" /></SelectTrigger>
-                    allowFreeText
+                    <SelectContent>
-                    commitOnType
+                      {wkPorts.length === 0 && !ultrabeam.com && <SelectItem value="_" disabled>{t('cat.noPorts')}</SelectItem>}
-                    showToggle
+                      {[...wkPorts, ...(ultrabeam.com && !wkPorts.includes(ultrabeam.com) ? [ultrabeam.com] : [])]
-                    placeholder="COM3"
+                        .map((pt) => <SelectItem key={pt} value={pt}>{pt}</SelectItem>)}
-                    className="font-mono flex-1"
+                    </SelectContent>
-                    onChange={(v) => setUltrabeam((s) => ({ ...s, com: v.trim().toUpperCase() }))}
+                  </Select>
-                  />
                   <Button type="button" variant="outline" size="sm" className="shrink-0"
                     onClick={() => ListSerialPorts().then((ps) => setWkPorts((ps ?? []) as string[])).catch(() => {})}>↻</Button>
                 </div>
@@ -3771,7 +3974,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <p className="text-xs text-muted-foreground pl-6">{t('hw.motorTxInhibitHint')}</p>
           </div>
           <div className="flex items-center gap-2 pt-2">
-            <Button variant="outline" size="sm" onClick={testUltrabeam} disabled={ubTesting || (isSerial ? !ultrabeam.com.trim() : !ultrabeam.host.trim())}>
+            <Button variant="outline" size="sm" onClick={testUltrabeam} disabled={ubTesting || (isSerial ? !(ultrabeam.com || '').trim() : !(ultrabeam.host || '').trim())}>
               {ubTesting ? t('hw.connecting') : t('hw.testConn')}
             </Button>
           </div>
@@ -3822,6 +4025,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>
       </>
     );
@@ -3933,15 +4168,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
         { value: 'acom1200', label: '1200S' },
         { value: 'acom2020', label: '2020S' },
       ],
+      kpa: [
+        { value: 'kpa1500', label: 'KPA1500' },
+        { value: 'kpa500', label: 'KPA500' },
+      ],
     };
-    const brandOf = (ty: string) => (!ty || ty === 'pgxl') ? 'pgxl' : ty.startsWith('acom') ? 'acom' : 'spe';
+    const brandOf = (ty: string) => (!ty || ty === 'pgxl') ? 'pgxl'
+      : ty.startsWith('acom') ? 'acom'
+      : ty.startsWith('kpa') ? 'kpa' : 'spe';
     const patchAmp = (i: number, patch: Partial<AmpUI>) => setAmps((l) => l.map((a, j) => (j === i ? { ...a, ...patch } : a)));
     // Each family has a fixed serial speed: SPE talks 115200, the ACOM S-series is
     // 9600 8N1 — preset it so switching brand just works. PGXL is TCP-only.
+    // Each family has its own fixed serial speed and its own default port, so
+    // switching model leaves a working configuration rather than one the
+    // operator has to repair. A KPA500 has no network side at all — it is put
+    // on serial here rather than being allowed to sit on a TCP setting that
+    // could never connect.
     const applyType = (i: number, v: string) => patchAmp(i, {
       type: v,
-      transport: v === 'pgxl' ? 'tcp' : amps[i].transport,
+      freq_out: v.startsWith('kpa') ? true : amps[i].freq_out,
-      baud: v.startsWith('acom') ? 9600 : v.startsWith('spe') ? 115200 : amps[i].baud,
+      transport: v === 'pgxl' ? 'tcp' : v === 'kpa500' ? 'serial' : amps[i].transport,
+      baud: v.startsWith('acom') ? 9600 : v.startsWith('spe') ? 115200 : v.startsWith('kpa') ? 38400 : amps[i].baud,
+      port: v === 'kpa1500' ? 1500 : amps[i].port,
     });
     const addAmp = () => setAmps((l) => [...l, {
       id: '', name: '', enabled: true, type: 'spe13', transport: 'tcp', host: '', port: 9008, com_port: '', baud: 115200,
@@ -3958,6 +4206,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             const brand = brandOf(amp.type);
             const isPGXL = brand === 'pgxl';
             const isACOM = brand === 'acom';
+            const isKPA = brand === 'kpa';
             const isSerial = !isPGXL && amp.transport === 'serial';
             return (
               <div key={amp.id || `new-${i}`} className="rounded-lg border border-border p-3 space-y-3">
@@ -3985,7 +4234,8 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                       <SelectContent>
                         <SelectItem value="pgxl">4O3A</SelectItem>
                         <SelectItem value="spe">SPE</SelectItem>
-                        <SelectItem value="acom">ACOM</SelectItem>
+                        <SelectItem value="acom">Acom</SelectItem>
+                        <SelectItem value="kpa">Elecraft</SelectItem>
                       </SelectContent>
                     </Select>
                   </div>
@@ -4075,10 +4325,27 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 )}
 
                 {/* Band-follow, for any amp that takes its band from a transceiver
-                    CAT link (ACOM and SPE both do) — never PowerGenius, which is
+                    CAT link (Acom and SPE both do) — never PowerGenius, which is
                     driven over its network protocol. A SECOND serial port,
-                    separate from the metering one above. */}
+                    separate from the metering one above.
-                {!isPGXL && (
+                    Never a KPA either: it has a band command of its own (^BN),
+                    so OpsLog tells it directly on the link it is already using.
+                    Offering a second serial port and a transceiver emulator for
+                    that would be a workaround for a problem this amplifier does
+                    not have. */}
+                {isKPA && (
+                  <div className="border-t border-border/60 pt-3 space-y-1">
+                    <label className="flex items-center gap-2 text-sm cursor-pointer">
+                      <Checkbox
+                        checked={!!amp.freq_out}
+                        onCheckedChange={(c) => patchAmp(i, { freq_out: !!c })}
+                      />
+                      {t('amp.kpaBandFollow')}
+                    </label>
+                    <p className="text-[11px] text-muted-foreground">{t('amp.kpaBandFollowHint')}</p>
+                  </div>
+                )}
+                {!isPGXL && !isKPA && (
                   <div className="border-t border-border/60 pt-3 space-y-3">
                     <label className="flex items-center gap-2 text-sm cursor-pointer">
                       <Checkbox
@@ -4918,11 +5185,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>
@@ -6499,6 +6773,13 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       xiegu: t('cat.optXiegu'),
     } as Record<string, string>)[catCfg.backend] ?? '';
 
+    // The radio-over-network entry, which ListAudioInputDevices and
+    // ListAudioOutputDevices add when the CAT link can carry audio. It is a
+    // real choice for two of the four fields and nonsense for the other two.
+    const NET_DEVICE = 'net:radio';
+    const soundCardsOnly = (devs: AudioDev[]) => devs.filter((d) => d.id !== NET_DEVICE);
+    const fromRadioIsNetwork = audioCfg.from_radio === NET_DEVICE;
+
     const deviceSelect = (
       field: keyof AudioSettings,
       devices: AudioDev[],
@@ -6533,23 +6814,35 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             {deviceSelect('from_radio', audioInputs, t('aud.phFromRadio'))}
             <Label className="text-sm">{t('aud.toRadio')}</Label>
             {deviceSelect('to_radio', audioOutputs, t('aud.phToRadio'))}
+            {/* The radio is offered for the two fields it can BE — where the
+                received audio comes from, and where the voice keyer sends
+                its messages — and taken out of the other two. It is not a
+                microphone: choosing it here would record the station you are
+                listening to instead of your own voice. And it is not a pair of
+                speakers: the audio going that way is transmit audio. */}
             <Label className="text-sm">{t('aud.recMic')}</Label>
-            {deviceSelect('recording_device', audioInputs, t('aud.phRecMic'))}
+            {deviceSelect('recording_device', soundCardsOnly(audioInputs), t('aud.phRecMic'))}
             <Label className="text-sm">{t('aud.listening')}</Label>
-            {deviceSelect('listening_device', audioOutputs, t('aud.phListening'))}
+            {deviceSelect('listening_device', soundCardsOnly(audioOutputs), t('aud.phListening'))}
           </div>
           <p className="text-[11px] text-muted-foreground">
             <strong>{t('aud.fromRadioShort')}</strong> {t('aud.explainFrom')}{' '}
             <strong>{t('aud.toRadioShort')}</strong> {t('aud.explainTo')}
           </p>
+
+          {/* The radio is one of the devices above when it can carry its own
+              audio — see ListAudioInputDevices. What used to be here was a test
+              bench: open the stream, record ten seconds, key a tone. It settled
+              how TCI works and has no business in front of an operator now that
+              choosing the device is the whole of the setup. */}
           <div className="flex items-center gap-3">
             <Button
               variant={monitorOn ? 'default' : 'outline'}
               size="sm"
               className="h-8"
               onClick={toggleMonitor}
-              disabled={!monitorOn && !audioCfg.from_radio}
+              disabled={!monitorOn && (!audioCfg.from_radio || fromRadioIsNetwork)}
-              title={t('aud.monitorTitle')}
+              title={fromRadioIsNetwork ? t('aud.monitorNoTci') : t('aud.monitorTitle')}
             >
               {monitorOn ? t('aud.stopListening') : t('aud.listenRadio')}
             </Button>
@@ -6842,7 +7135,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
           </label>
           <TelemetryToggle />
 
-          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} yaesuAvailable={yaesuAvailable} />
+          <MainViewPanes onChanged={onMainPaneChanged} flexAvailable={flexAvailable} icomAvailable={icomAvailable} yaesuAvailable={yaesuAvailable} elecraftAvailable={elecraftAvailable} tciAvailable={tciAvailable} />
 
           <div className="border-t border-border/60 pt-4 space-y-2">
             <h4 className="text-sm font-semibold text-foreground">{t('gen.pwEnc')}</h4>
@@ -7250,7 +7543,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>
@@ -7264,8 +7557,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', {
@@ -7278,7 +7572,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>
@@ -7287,23 +7593,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>
@@ -7323,6 +7732,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
@@ -7337,7 +7747,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,
@@ -7505,6 +7924,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/ShiftRow.tsx

@@ -0,0 +1,91 @@
+import { useEffect, useRef, useState } from 'react';
+import { cn } from '@/lib/utils';
+
+// ShiftRow — the RIT / XIT offset control, shared by the radio consoles.
+//
+// It began inside the Icom panel and is here because the next console needed
+// exactly it. Consoles that each invent their own way of nudging an offset make
+// an operator learn the same thing twice, which is the complaint that moved it:
+// "none of the consoles look alike".
+//
+// Three ways to move it, because operators reach for different ones: the ± keys,
+// the wheel over the number, and TYPING a value straight in. The last one is
+// what a button row cannot do — 'put me 300 Hz down' is one keystroke sequence,
+// not thirty clicks.
+export function ShiftRow({ label, on, hz, accent, disabled, step = 10, onToggle, onSet }: {
+  label: string;
+  on: boolean;
+  hz: number;
+  accent: string;
+  disabled?: boolean;
+  step?: number;
+  onToggle: () => void;
+  onSet: (hz: number) => void;
+}) {
+  const ref = useRef<HTMLDivElement>(null);
+  const [editing, setEditing] = useState<string | null>(null);
+  const cb = useRef(onSet); cb.current = onSet;
+  const cur = useRef({ hz, on, disabled }); cur.current = { hz, on, disabled };
+
+  // Wheel over the row. A native non-passive listener, because React's onWheel
+  // is passive and cannot preventDefault — without that the panel scrolls under
+  // the pointer while the number changes.
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      const c = cur.current;
+      if (c.disabled || !c.on) return;
+      e.preventDefault();
+      cb.current(c.hz + (e.deltaY < 0 ? step : -step));
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, [step]);
+
+  const commit = (raw: string) => {
+    setEditing(null);
+    const v = parseInt(raw.replace(/[^0-9+-]/g, ''), 10);
+    if (!Number.isNaN(v)) onSet(v);
+  };
+
+  const dead = disabled || !on;
+  return (
+    <div className="flex items-center gap-2">
+      <button type="button" onClick={onToggle} disabled={disabled}
+        className={cn('w-14 shrink-0 px-2 py-1 rounded-md text-[11px] font-bold border transition-colors disabled:opacity-30',
+          on ? 'bg-success border-success text-success-foreground' : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+        {label}
+      </button>
+      <div ref={ref} title="Wheel, ± or type"
+        className={cn('flex-1 flex items-center justify-between rounded-md border px-1 py-0.5 select-none',
+          dead ? 'border-border/60 bg-muted/20 opacity-60' : 'border-border bg-muted/40 cursor-ns-resize')}>
+        <button type="button" disabled={dead} onClick={() => onSet(hz - step)}
+          className="px-2 text-sm font-bold text-muted-foreground hover:text-foreground disabled:opacity-40">−</button>
+        {editing !== null ? (
+          <input
+            autoFocus
+            value={editing}
+            onChange={(e) => setEditing(e.target.value)}
+            onBlur={(e) => commit(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter') commit((e.target as HTMLInputElement).value);
+              else if (e.key === 'Escape') setEditing(null);
+            }}
+            className="w-20 bg-transparent text-center text-sm font-mono font-bold tabular-nums outline-none"
+          />
+        ) : (
+          <button type="button" disabled={dead} onClick={() => setEditing(String(hz))}
+            className="text-sm font-mono font-bold tabular-nums disabled:cursor-default"
+            style={{ color: on ? accent : undefined }}>
+            {hz > 0 ? '+' : hz < 0 ? '−' : ''}{Math.abs(hz)} Hz
+          </button>
+        )}
+        <button type="button" disabled={dead} onClick={() => onSet(hz + step)}
+          className="px-2 text-sm font-bold text-muted-foreground hover:text-foreground disabled:opacity-40">+</button>
+      </div>
+      <button type="button" disabled={dead} onClick={() => onSet(0)}
+        className="w-8 shrink-0 py-1 rounded-md text-[11px] font-bold border border-border bg-card text-muted-foreground hover:bg-muted disabled:opacity-30">0</button>
+    </div>
+  );
+}

frontend/src/components/TCIPanel.tsx

@@ -0,0 +1,411 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, Activity, AudioLines, SlidersHorizontal, Mic } from 'lucide-react';
+import {
+  GetTCIPanel, GetCATState,
+  SetTCIDrive, SetTCITuneDrive, SetTCIMicLevel, SetTCIVolume, SetTCIMute,
+  SetTCIAGC, SetTCISquelch, SetTCISquelchLevel,
+  SetTCINB, SetTCINR, SetTCIANF, SetTCIAPF, SetTCIFilter,
+  SetTCIRIT, SetTCIXIT, SetTCIRITOffset, SetTCIXITOffset, SetTCILock, SetTCITune,
+} from '../../wailsjs/go/main/App';
+import { cn } from '@/lib/utils';
+import { useI18n } from '@/lib/i18n';
+import { sMeterRST } from '@/lib/rst';
+import { MeterBar } from '@/components/MeterBar';
+import { WheelRange } from '@/components/WheelRange';
+import { ShiftRow } from '@/components/ShiftRow';
+import { LevelRow } from '@/components/LevelRow';
+
+type TCIState = {
+  connected: boolean; device?: string; protocol?: string;
+  drive: number; tune_drive: number; mic_level: number; tx_enabled: boolean; tx: boolean; tuning: boolean;
+  volume: number; mute: boolean; agc?: string; squelch_on: boolean; squelch: number;
+  nb: boolean; nr: boolean; anf: boolean; apf: boolean;
+  filter_lo: number; filter_hi: number;
+  rit: boolean; rit_offset: number; xit: boolean; xit_offset: number; lock: boolean; split: boolean;
+  smeter: number; modulations?: string[];
+  tx_power_w: number; tx_swr: number;
+};
+
+const ZERO: TCIState = {
+  connected: false, drive: 0, tune_drive: 0, mic_level: 0, tx_enabled: false, tx: false, tuning: false,
+  volume: 0, mute: false, squelch_on: false, squelch: 0,
+  nb: false, nr: false, anf: false, apf: false, filter_lo: 0, filter_hi: 0,
+  rit: false, rit_offset: 0, xit: false, xit_offset: 0, lock: false, split: false, smeter: 0,
+  tx_power_w: 0, tx_swr: 0,
+};
+
+// The widths worth a button, PER MODE — because 250 Hz is useless in SSB and
+// 2.8 kHz is useless in CW, and a row offering both is a row where half the
+// buttons are never pressed.
+//
+// CW gets the narrow end, where the difference between 250 and 500 is the
+// difference between one signal and three. Voice gets the range a passband is
+// actually shaped over. Digital sits between: wide enough for a whole FT8
+// sub-band, narrow enough for RTTY.
+const WIDTHS_CW = [100, 250, 400, 500, 700, 1000, 1800];
+const WIDTHS_SSB = [1800, 2100, 2400, 2700, 2800, 3000, 3500];
+const WIDTHS_DIGI = [500, 1000, 1800, 2400, 2800, 3000, 3500];
+
+// widthsFor picks the row from the mode the radio reports.
+function widthsFor(mode: string): number[] {
+  if (/CW/i.test(mode)) return WIDTHS_CW;
+  if (/SSB|USB|LSB|AM|FM/i.test(mode)) return WIDTHS_SSB;
+  return WIDTHS_DIGI;
+}
+
+// isCW says whether the CW-only controls belong on screen at all.
+function isCW(mode: string): boolean { return /CW/i.test(mode); }
+
+function widthLabel(w: number): string {
+  return w >= 1000 ? `${(w / 1000).toFixed(1)}k` : String(w);
+}
+
+// edgesFor turns a width into the pair TCI wants: 0 to the width, and nothing
+// clever.
+//
+// It centred narrow filters on the CW note first — 250 became 575-825 — on the
+// reasoning that a CW filter should contain the note. That reasoning may even be
+// right for a radio, but it is not what the button says, and a button that does
+// not do what it says is worse than one that does something simple. 250 means
+// 0-250. The two edges are editable underneath for anything else.
+function edgesFor(w: number, _mode: string): { lo: number; hi: number } {
+  return { lo: 0, hi: w };
+}
+
+// dBm → S units. TCI reports a real signal level rather than a meter position,
+// which is the useful way round: S9 is -73 dBm by the IARU definition and every
+// S unit below it is 6 dB, so this is arithmetic rather than a calibration
+// table — nothing here is provisional the way the K3's meter reading is.
+function sParts(dbm: number): { s: number; over: number; label: string } {
+  if (dbm === 0) return { s: 0, over: 0, label: '—' };
+  if (dbm >= -73) {
+    const over = Math.round((dbm + 73) / 10) * 10;
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, Math.round(9 + (dbm + 73) / 6)));
+  return { s, over: 0, label: `S${s}` };
+}
+
+// The meter bar wants 0-100; -127 dBm is the bottom of the scale and -13 dBm
+// (S9+60) the top.
+function sBar(dbm: number): number {
+  if (dbm === 0) return 0;
+  return Math.max(0, Math.min(100, ((dbm + 127) / 114) * 100));
+}
+
+function sSegColor(frac: number): string {
+  return frac > 0.75 ? '#dc2626' : frac > 0.55 ? '#f59e0b' : '#16a34a';
+}
+
+function Card({ icon: Icon, title, children }: { icon: any; title: string; children: React.ReactNode }) {
+  return (
+    <div className="rounded-xl border border-border bg-card shadow-sm overflow-hidden">
+      <div className="flex items-center gap-2 px-3 py-2 border-b border-border/60 bg-muted/30">
+        <Icon className="size-4 text-primary" />
+        <span className="text-xs font-bold uppercase tracking-wider text-foreground/80">{title}</span>
+      </div>
+      <div className="p-3 space-y-3">{children}</div>
+    </div>
+  );
+}
+
+// One button shape for every on/off control, as on the other consoles.
+function Toggle({ label, on, off, onClick, title }: {
+  label: string; on: boolean; off: boolean; onClick: () => void; title?: string;
+}) {
+  return (
+    <button type="button" disabled={off} onClick={onClick} title={title}
+      className={cn('rounded-lg border-2 px-2 py-1.5 text-xs font-bold transition-all disabled:opacity-30',
+        on ? 'bg-primary text-primary-foreground border-primary shadow-[0_0_10px] shadow-primary/40'
+          : 'bg-card text-muted-foreground border-border hover:bg-muted')}>
+      {label}
+    </button>
+  );
+}
+
+function Row({ label, value, children }: { label: string; value: string; children: React.ReactNode }) {
+  return (
+    <div className="space-y-1">
+      <div className="flex items-baseline justify-between">
+        <span className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground">{label}</span>
+        <span className="text-xs font-mono tabular-nums">{value}</span>
+      </div>
+      {children}
+    </div>
+  );
+}
+
+export function TCIPanel({ onReportRST }: { onReportRST?: (rst: string) => void } = {}) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<TCIState>(ZERO);
+  const [freqHz, setFreqHz] = useState(0);
+  const [mode, setMode] = useState('');
+  const [err, setErr] = useState('');
+
+  // OPTIMISTIC, like the Icom console — and for a reason found on a real radio.
+  //
+  // This panel used to show only what the radio reported back, on the principle
+  // that the radio is the truth. But ExpertSDR3 does not echo every setting it
+  // is given: press MED and the radio changes, says nothing, and the button
+  // stays lit on SLOW. Waiting for an answer that never comes reads as a dead
+  // control.
+  //
+  // So a change is shown at once and held for a moment. Whatever the radio
+  // announces afterwards — the new value, or a refusal that leaves the old one
+  // — wins once the hold expires, which keeps a clamped or rejected setting
+  // honest without making every working one look broken.
+  // Held UNTIL THE RADIO SPEAKS, not for a fixed moment.
+  //
+  // A timeout was wrong in both directions. Too short and a setting the radio
+  // never echoes — AGC is one — snapped back to its old value a second after
+  // the click. Too long and a setting the radio REFUSES looked accepted: a real
+  // log shows this one answering 'sql_enable:0,false' and then, eighty
+  // milliseconds later, 'sql_enable:0,true' — it puts the squelch straight back
+  // on. Holding through that would have shown the operator a lie.
+  //
+  // So the requested value stands while the radio says nothing about it, and
+  // the instant it reports ANY change for that setting, its word replaces ours.
+  const holdRef = useRef<Record<string, { v: any; reported: any }>>({});
+  const [, forceRender] = useState(0);
+  const hold = <T,>(key: string, reported: T): T => {
+    const h = holdRef.current[key];
+    if (!h) return reported;
+    // The radio has said something different from what it was saying when the
+    // click happened — whether that is our value or a refusal, it is now the
+    // truth and the hold is over.
+    if (reported !== h.reported) {
+      delete holdRef.current[key];
+      return reported;
+    }
+    return h.v as T;
+  };
+  const setHold = (key: string, v: any, reported: any) => {
+    holdRef.current[key] = { v, reported };
+    forceRender((n) => n + 1);
+  };
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const p: any = await GetTCIPanel();
+        if (!alive) return;
+        setSt(p as TCIState);
+        const cs: any = await GetCATState();
+        if (!alive) return;
+        setFreqHz(Number(cs?.rx_freq_hz) || Number(cs?.freq_hz) || 0);
+        setMode(String(cs?.mode || ''));
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 400);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const off = !st.connected;
+
+  const call = (fn: () => Promise<any>) => { fn().catch((e: any) => setErr(String(e?.message ?? e))); };
+
+  const drive = hold('drive', st.drive);
+  const tuneDrive = hold('tune_drive', st.tune_drive);
+  const mic = hold('mic', st.mic_level);
+  const vol = hold('vol', st.volume);
+  const sql = hold('sql', st.squelch);
+  const agc = hold('agc', st.agc || '');
+  const nb = hold('nb', st.nb), nr = hold('nr', st.nr);
+  const anf = hold('anf', st.anf), apf = hold('apf', st.apf);
+  const sqlOn = hold('sql_on', st.squelch_on), muted = hold('mute', st.mute);
+  const rit = hold('rit', st.rit), xit = hold('xit', st.xit);
+  const ritHz = hold('rit_hz', st.rit_offset), xitHz = hold('xit_hz', st.xit_offset);
+  const s = sParts(st.smeter);
+
+  // Ctrl+Left/Right shifts the RIT by ±10 Hz, the same keys the Icom console
+  // uses. Two consoles for two radios should not need two habits.
+  const ritRef = useRef({ on: false, hz: 0, off: true });
+  ritRef.current = { on: rit, hz: ritHz, off };
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (!e.ctrlKey || (e.key !== 'ArrowLeft' && e.key !== 'ArrowRight')) return;
+      const r = ritRef.current;
+      if (r.off || !r.on) return;
+      e.preventDefault();
+      const v = r.hz + (e.key === 'ArrowRight' ? 10 : -10);
+      setHold('rit_hz', v, ritRef.current.hz);
+      SetTCIRITOffset(v).catch(() => {});
+    };
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, []);
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      {/* Capped and centred, like the Elecraft, Yaesu, Icom and Flex consoles.
+          Stretched across a wide window a console puts each slider a hand's
+          width from its own label and stops reading as one instrument. */}
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+        {/* VFO + identity */}
+        <div className="rounded-xl border border-border bg-card shadow-sm px-4 py-3 flex items-center justify-between gap-3 flex-wrap">
+          <div>
+            <div className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground flex items-center gap-1.5">
+              <Radio className="size-3.5" />
+              {st.device || 'SunSDR'} {st.protocol ? `· ${st.protocol}` : ''}
+              <span className={cn('size-2 rounded-full', off ? 'bg-muted-foreground/40' : 'bg-success')} />
+            </div>
+            <div className="text-2xl font-mono tabular-nums font-bold">
+              {freqHz > 0 ? (freqHz / 1e6).toFixed(6) : '—'}
+            </div>
+          </div>
+          <div className="flex items-center gap-2">
+            {st.tx && <span className="rounded-md bg-danger px-2 py-1 text-[11px] font-bold text-danger-foreground">TX</span>}
+            {st.split && <span className="rounded-md border border-border px-2 py-1 text-[11px] font-bold">SPLIT</span>}
+            <Toggle label={t('tcip.lock')} on={st.lock} off={off} onClick={() => call(() => SetTCILock(!st.lock))} />
+          </div>
+        </div>
+
+        {off && <div className="text-xs text-muted-foreground px-1">{t('tcip.waiting')}</div>}
+        {!!err && <div className="text-[11px] text-danger px-1">{err}</div>}
+
+        {/* Meters. The S-meter while receiving, power and SWR while
+            transmitting — the radio answers TX_POWER and TX_SWR only when it is
+            keyed, so showing them the rest of the time would be showing the
+            last thing that happened as if it were now.
+            There is no temperature: the protocol has no such command, and a
+            made-up figure on a transmitter is the kind somebody trusts. */}
+        <Card icon={Activity} title={t('tcip.meters')}>
+          <MeterBar label="S-METER" value={st.tx || st.tuning ? 0 : sBar(st.smeter)} lo={0} hi={100}
+            accent="#16a34a" segColor={sSegColor}
+            display={st.tx || st.tuning ? '—' : `${s.label}  ${st.smeter} dBm`}
+            onClick={() => {
+              if (st.tx || !onReportRST) return;
+              onReportRST(sMeterRST(s.s, s.over, mode));
+            }}
+            title={t('tcip.sMeterHint')} />
+          {(st.tx || st.tuning) && (
+            <div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
+              <MeterBar label="PWR" value={st.tx_power_w} lo={0} hi={Math.max(10, Math.ceil(st.tx_power_w / 10) * 10)}
+                accent="#0ea5e9" display={`${st.tx_power_w.toFixed(1)} W`} />
+              {/* 0 is "not measured yet", and it must not draw as a perfect
+                  match: an SWR of 1.0 on an antenna nobody has measured is the
+                  one reading an operator should not be handed. */}
+              <MeterBar label="SWR" value={st.tx_swr > 0 ? Math.min(100, (st.tx_swr - 1) * 50) : 0} lo={0} hi={100}
+                accent="#f59e0b" display={st.tx_swr > 0 ? st.tx_swr.toFixed(1) : '—'}
+                segColor={(f) => (f > 0.5 ? '#dc2626' : f > 0.25 ? '#f59e0b' : '#16a34a')} />
+            </div>
+          )}
+        </Card>
+
+        {/* Transmit */}
+        <Card icon={SlidersHorizontal} title={t('tcip.transmit')}>
+          {/* One level per ROW, full width. Two half-width sliders side by side
+              left each of them a couple of centimetres long — small enough that
+              setting 15% took aim. */}
+          <LevelRow label={t('tcip.drive')} unit="%" value={drive} disabled={off}
+            onSet={(v) => { setHold('drive', v, st.drive); call(() => SetTCIDrive(v)); }} />
+          <LevelRow label={t('tcip.tuneDrive')} unit="%" value={tuneDrive} disabled={off} accent="#f59e0b"
+            onSet={(v) => { setHold('tune_drive', v, st.tune_drive); call(() => SetTCITuneDrive(v)); }} />
+          <div className="flex items-center gap-2 flex-wrap">
+            {/* TUNE transmits, and at the tune drive rather than the main one —
+                which is why both numbers are above the button rather than one of
+                them being in a menu somewhere. */}
+            <button type="button" disabled={off || !st.tx_enabled}
+              onClick={() => call(() => SetTCITune(!st.tuning))}
+              className={cn('rounded-lg border-2 px-4 py-2 text-sm font-extrabold tracking-wide transition-all disabled:opacity-30',
+                st.tuning ? 'bg-warning text-warning-foreground border-warning shadow-[0_0_14px] shadow-warning/50'
+                  : 'bg-card text-warning border-warning hover:bg-warning-muted')}>
+              {st.tuning ? t('tcip.tuning') : t('tcip.tune')}
+            </button>
+            {!st.tx_enabled && !off && (
+              <span className="text-[11px] text-muted-foreground">{t('tcip.txDisabled')}</span>
+            )}
+          </div>
+          <LevelRow label={t('tcip.mic')} unit="%" value={mic} disabled={off} accent="#a855f7"
+            onSet={(v) => { setHold('mic', v, st.mic_level); call(() => SetTCIMicLevel(v)); }} />
+        </Card>
+
+        {/* Receive */}
+        <Card icon={AudioLines} title={t('tcip.receive')}>
+          {/* Both in the radio's OWN units — volume in dB, negative, and the
+              squelch as a dBm threshold — so the numbers match the ones in
+              ExpertSDR3's window rather than being percentages of something. */}
+          <LevelRow label={t('tcip.volume')} unit=" dB" min={-60} max={0} value={vol} disabled={off}
+            onSet={(v) => { setHold('vol', v, st.volume); call(() => SetTCIVolume(v)); }} />
+          <LevelRow label={t('tcip.squelch')} unit=" dBm" min={-140} max={0} value={sql}
+            disabled={off || !sqlOn} accent="#38bdf8"
+            onSet={(v) => { setHold('sql', v, st.squelch); call(() => SetTCISquelchLevel(v)); }} />
+          <div className={cn('grid gap-2', isCW(mode) ? 'grid-cols-3 sm:grid-cols-6' : 'grid-cols-3 sm:grid-cols-5')}>
+            <Toggle label="NB" on={nb} off={off} onClick={() => { setHold('nb', !nb, st.nb); call(() => SetTCINB(!nb)); }} />
+            <Toggle label="NR" on={nr} off={off} onClick={() => { setHold('nr', !nr, st.nr); call(() => SetTCINR(!nr)); }} />
+            <Toggle label="ANF" on={anf} off={off} onClick={() => { setHold('anf', !anf, st.anf); call(() => SetTCIANF(!anf)); }} />
+            {/* APF is an audio PEAK filter — it rings a single tone out of the
+                noise, which is a CW tool and nothing else. Shown only there:
+                off CW it is not a control, it is a puzzle. */}
+            {isCW(mode) && (
+              <Toggle label="APF" on={apf} off={off} onClick={() => { setHold('apf', !apf, st.apf); call(() => SetTCIAPF(!apf)); }} />
+            )}
+            <Toggle label="SQL" on={sqlOn} off={off} onClick={() => { setHold('sql_on', !sqlOn, st.squelch_on); call(() => SetTCISquelch(!sqlOn)); }} />
+            <Toggle label={t('tcip.mute')} on={muted} off={off} onClick={() => { setHold('mute', !muted, st.mute); call(() => SetTCIMute(!muted)); }} />
+          </div>
+          <div className="space-y-1">
+            <span className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground">{t('tcip.agc')}</span>
+            {/* LONG is gone. The protocol accepts it, but it is a hang time
+                nobody reaches for between overs, and a fifth button that has to
+                be explained is worse than four that do not. */}
+            <div className="grid grid-cols-4 gap-2">
+              {['off', 'slow', 'med', 'fast'].map((m) => (
+                <Toggle key={m} label={m.toUpperCase()} on={agc === m} off={off}
+                  onClick={() => { setHold('agc', m, st.agc || ''); call(() => SetTCIAGC(m)); }} />
+              ))}
+            </div>
+          </div>
+          <div className="space-y-1">
+            <div className="flex items-baseline justify-between">
+              <span className="text-[10px] font-bold uppercase tracking-wider text-muted-foreground">{t('tcip.filter')}</span>
+              <span className="text-xs font-mono tabular-nums">{st.filter_lo}–{st.filter_hi} Hz</span>
+            </div>
+            <div className="flex items-center gap-2 pb-1">
+              <LevelRow label="LO" unit=" Hz" min={-5000} max={5000} step={10}
+                value={st.filter_lo} disabled={off}
+                onSet={(v) => call(() => SetTCIFilter(v, st.filter_hi))} />
+            </div>
+            <div className="flex items-center gap-2 pb-1">
+              <LevelRow label="HI" unit=" Hz" min={-5000} max={5000} step={10}
+                value={st.filter_hi} disabled={off}
+                onSet={(v) => call(() => SetTCIFilter(st.filter_lo, v))} />
+            </div>
+            <div className="grid grid-cols-4 sm:grid-cols-7 gap-2">
+              {widthsFor(mode).map((w) => {
+                const e = edgesFor(w, mode);
+                // Lit by the WIDTH the radio is actually using, not by an exact
+                // pair of edges: the operator may have moved one edge on the
+                // radio, and a button that only lights on our own numbers would
+                // go dark for a filter that is plainly 500 Hz wide.
+                const on = Math.abs((st.filter_hi - st.filter_lo) - w) <= 50;
+                return (
+                  <Toggle key={w} label={widthLabel(w)} on={on} off={off}
+                    title={`${e.lo}–${e.hi} Hz`}
+                    onClick={() => call(() => SetTCIFilter(e.lo, e.hi))} />
+                );
+              })}
+            </div>
+          </div>
+        </Card>
+
+        {/* RIT / XIT — the SAME control the Icom console uses, now shared
+            rather than reinvented: a chip, a signed offset you can type into,
+            scroll on, or step with ±, and a zero. Ctrl+←/→ shifts the RIT. */}
+        <Card icon={Mic} title="RIT / XIT">
+          <div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
+            <ShiftRow label="RIT" on={rit} hz={ritHz} accent="#38bdf8" disabled={off}
+              onToggle={() => { setHold('rit', !rit, st.rit); call(() => SetTCIRIT(!rit)); }}
+              onSet={(v) => { setHold('rit_hz', v, st.rit_offset); call(() => SetTCIRITOffset(v)); }} />
+            <ShiftRow label="XIT" on={xit} hz={xitHz} accent="#f59e0b" disabled={off}
+              onToggle={() => { setHold('xit', !xit, st.xit); call(() => SetTCIXIT(!xit)); }}
+              onSet={(v) => { setHold('xit_hz', v, st.xit_offset); call(() => SetTCIXITOffset(v)); }} />
+          </div>
+        </Card>
+      </div>
+    </div>
+  );
+}

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.18';
 
 // 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,6 +577,8 @@ export function GetStationSettings():Promise<main.StationSettings>;
 
 export function GetStationStatus():Promise<Array<main.StationDeviceStatus>>;
 
+export function GetTCIPanel():Promise<cat.TCIPanelState>;
+
 export function GetTelemetryEnabled():Promise<boolean>;
 
 export function GetTrackedAwards():Promise<Array<string>>;
@@ -803,6 +807,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>;
@@ -1155,6 +1161,44 @@ export function SetSpotMax(arg1:number):Promise<void>;
 
 export function SetSpotTTLMinutes(arg1:number):Promise<void>;
 
+export function SetTCIAGC(arg1:string):Promise<void>;
+
+export function SetTCIANF(arg1:boolean):Promise<void>;
+
+export function SetTCIAPF(arg1:boolean):Promise<void>;
+
+export function SetTCIDrive(arg1:number):Promise<void>;
+
+export function SetTCIFilter(arg1:number,arg2:number):Promise<void>;
+
+export function SetTCILock(arg1:boolean):Promise<void>;
+
+export function SetTCIMicLevel(arg1:number):Promise<void>;
+
+export function SetTCIMute(arg1:boolean):Promise<void>;
+
+export function SetTCINB(arg1:boolean):Promise<void>;
+
+export function SetTCINR(arg1:boolean):Promise<void>;
+
+export function SetTCIRIT(arg1:boolean):Promise<void>;
+
+export function SetTCIRITOffset(arg1:number):Promise<void>;
+
+export function SetTCISquelch(arg1:boolean):Promise<void>;
+
+export function SetTCISquelchLevel(arg1:number):Promise<void>;
+
+export function SetTCITune(arg1:boolean):Promise<void>;
+
+export function SetTCITuneDrive(arg1:number):Promise<void>;
+
+export function SetTCIVolume(arg1:number):Promise<void>;
+
+export function SetTCIXIT(arg1:boolean):Promise<void>;
+
+export function SetTCIXITOffset(arg1:number):Promise<void>;
+
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
 
 export function SetUIPref(arg1:string,arg2:string):Promise<void>;

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,6 +1094,10 @@ export function GetStationStatus() {
   return window['go']['main']['App']['GetStationStatus']();
 }
 
+export function GetTCIPanel() {
+  return window['go']['main']['App']['GetTCIPanel']();
+}
+
 export function GetTelemetryEnabled() {
   return window['go']['main']['App']['GetTelemetryEnabled']();
 }
@@ -1546,6 +1554,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']();
 }
@@ -2250,6 +2262,82 @@ export function SetSpotTTLMinutes(arg1) {
   return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
 }
 
+export function SetTCIAGC(arg1) {
+  return window['go']['main']['App']['SetTCIAGC'](arg1);
+}
+
+export function SetTCIANF(arg1) {
+  return window['go']['main']['App']['SetTCIANF'](arg1);
+}
+
+export function SetTCIAPF(arg1) {
+  return window['go']['main']['App']['SetTCIAPF'](arg1);
+}
+
+export function SetTCIDrive(arg1) {
+  return window['go']['main']['App']['SetTCIDrive'](arg1);
+}
+
+export function SetTCIFilter(arg1, arg2) {
+  return window['go']['main']['App']['SetTCIFilter'](arg1, arg2);
+}
+
+export function SetTCILock(arg1) {
+  return window['go']['main']['App']['SetTCILock'](arg1);
+}
+
+export function SetTCIMicLevel(arg1) {
+  return window['go']['main']['App']['SetTCIMicLevel'](arg1);
+}
+
+export function SetTCIMute(arg1) {
+  return window['go']['main']['App']['SetTCIMute'](arg1);
+}
+
+export function SetTCINB(arg1) {
+  return window['go']['main']['App']['SetTCINB'](arg1);
+}
+
+export function SetTCINR(arg1) {
+  return window['go']['main']['App']['SetTCINR'](arg1);
+}
+
+export function SetTCIRIT(arg1) {
+  return window['go']['main']['App']['SetTCIRIT'](arg1);
+}
+
+export function SetTCIRITOffset(arg1) {
+  return window['go']['main']['App']['SetTCIRITOffset'](arg1);
+}
+
+export function SetTCISquelch(arg1) {
+  return window['go']['main']['App']['SetTCISquelch'](arg1);
+}
+
+export function SetTCISquelchLevel(arg1) {
+  return window['go']['main']['App']['SetTCISquelchLevel'](arg1);
+}
+
+export function SetTCITune(arg1) {
+  return window['go']['main']['App']['SetTCITune'](arg1);
+}
+
+export function SetTCITuneDrive(arg1) {
+  return window['go']['main']['App']['SetTCITuneDrive'](arg1);
+}
+
+export function SetTCIVolume(arg1) {
+  return window['go']['main']['App']['SetTCIVolume'](arg1);
+}
+
+export function SetTCIXIT(arg1) {
+  return window['go']['main']['App']['SetTCIXIT'](arg1);
+}
+
+export function SetTCIXITOffset(arg1) {
+  return window['go']['main']['App']['SetTCIXITOffset'](arg1);
+}
+
 export function SetTelemetryEnabled(arg1) {
   return window['go']['main']['App']['SetTelemetryEnabled'](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,6 +1210,76 @@ export namespace cat {
 	        this.fixed = source["fixed"];
 	    }
 	}
+	export class TCIPanelState {
+	    connected: boolean;
+	    device?: string;
+	    protocol?: string;
+	    drive: number;
+	    tune_drive: number;
+	    mic_level: number;
+	    tx_enabled: boolean;
+	    tx: boolean;
+	    tuning: boolean;
+	    volume: number;
+	    mute: boolean;
+	    agc?: string;
+	    squelch_on: boolean;
+	    squelch: number;
+	    nb: boolean;
+	    nr: boolean;
+	    anf: boolean;
+	    apf: boolean;
+	    filter_lo: number;
+	    filter_hi: number;
+	    rit: boolean;
+	    rit_offset: number;
+	    xit: boolean;
+	    xit_offset: number;
+	    lock: boolean;
+	    split: boolean;
+	    smeter: number;
+	    tx_power_w: number;
+	    tx_swr: number;
+	    modulations?: string[];
+	
+	    static createFrom(source: any = {}) {
+	        return new TCIPanelState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.connected = source["connected"];
+	        this.device = source["device"];
+	        this.protocol = source["protocol"];
+	        this.drive = source["drive"];
+	        this.tune_drive = source["tune_drive"];
+	        this.mic_level = source["mic_level"];
+	        this.tx_enabled = source["tx_enabled"];
+	        this.tx = source["tx"];
+	        this.tuning = source["tuning"];
+	        this.volume = source["volume"];
+	        this.mute = source["mute"];
+	        this.agc = source["agc"];
+	        this.squelch_on = source["squelch_on"];
+	        this.squelch = source["squelch"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.anf = source["anf"];
+	        this.apf = source["apf"];
+	        this.filter_lo = source["filter_lo"];
+	        this.filter_hi = source["filter_hi"];
+	        this.rit = source["rit"];
+	        this.rit_offset = source["rit_offset"];
+	        this.xit = source["xit"];
+	        this.xit_offset = source["xit_offset"];
+	        this.lock = source["lock"];
+	        this.split = source["split"];
+	        this.smeter = source["smeter"];
+	        this.tx_power_w = source["tx_power_w"];
+	        this.tx_swr = source["tx_swr"];
+	        this.modulations = source["modulations"];
+	    }
+	}
 	export class YaesuTXState {
 	    available: boolean;
 	    model?: string;
@@ -1498,6 +1570,51 @@ export namespace extsvc {
 
 }
 
+export namespace kpa {
+	
+	export class Status {
+	    connected: boolean;
+	    transport: string;
+	    model?: string;
+	    last_error?: string;
+	    power_on: boolean;
+	    operate: boolean;
+	    fwd_w: number;
+	    swr: number;
+	    volt_v: number;
+	    cur_a: number;
+	    temp_c: number;
+	    band?: string;
+	    tuning: boolean;
+	    fault_code: number;
+	    fault_text?: string;
+	
+	    static createFrom(source: any = {}) {
+	        return new Status(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.connected = source["connected"];
+	        this.transport = source["transport"];
+	        this.model = source["model"];
+	        this.last_error = source["last_error"];
+	        this.power_on = source["power_on"];
+	        this.operate = source["operate"];
+	        this.fwd_w = source["fwd_w"];
+	        this.swr = source["swr"];
+	        this.volt_v = source["volt_v"];
+	        this.cur_a = source["cur_a"];
+	        this.temp_c = source["temp_c"];
+	        this.band = source["band"];
+	        this.tuning = source["tuning"];
+	        this.fault_code = source["fault_code"];
+	        this.fault_text = source["fault_text"];
+	    }
+	}
+
+}
+
 export namespace lookup {
 	
 	export class Result {
@@ -1699,6 +1816,7 @@ export namespace main {
 	    pgxl?: powergenius.Status;
 	    spe?: spe.Status;
 	    acom?: acom.Status;
+	    kpa?: kpa.Status;
 	
 	    static createFrom(source: any = {}) {
 	        return new AmpStatus(source);
@@ -1712,6 +1830,7 @@ export namespace main {
 	        this.pgxl = this.convertValues(source["pgxl"], powergenius.Status);
 	        this.spe = this.convertValues(source["spe"], spe.Status);
 	        this.acom = this.convertValues(source["acom"], acom.Status);
+	        this.kpa = this.convertValues(source["kpa"], kpa.Status);
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {
@@ -1736,6 +1855,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);
@@ -1746,6 +1867,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 {
@@ -2146,6 +2269,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;
@@ -2197,6 +2321,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"];
@@ -2831,6 +2956,7 @@ export namespace main {
 	    rst_phone: string[];
 	    rst_cw: string[];
 	    rst_digital: string[];
+	    satellites: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new ListsSettings(source);
@@ -2843,6 +2969,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 {
@@ -3339,6 +3466,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/alerts/alerts.go

@@ -264,9 +264,18 @@ func matchWildcard(pattern, v string) bool {
 	return re.MatchString(v)
 }
 
-// InferMode guesses a spot's mode from its comment and frequency. Cluster spots
+// InferMode works out a spot's mode from its comment, then from the band plan.
-// don't carry a mode field, so we read common tags (FT8/FT4/CW/RTTY/…) then fall
+//
-// back to the digital watering holes and the band-plan CW/phone split.
+// Cluster lines carry no mode field, so this is all there is — and it feeds the
+// alert rules, the FlexRadio panadapter colours and the spot the radio is told
+// about. It used to end with a bare "return SSB" for anything its handful of CW
+// ranges did not cover, which is how a 30 m FT8 spot at 10131.5 raised an alert
+// announcing SSB while the cluster list beside it said DATA.
+//
+// The comment still wins when it names a mode: a spotter who wrote FT8 knows
+// better than any table. Below that is the shared band plan (bandplan.go), and
+// below THAT is nothing — an empty mode, which callers read as "unknown" rather
+// than as a claim.
 func InferMode(comment string, freqHz int64) string {
 	c := strings.ToUpper(comment)
 	switch {
@@ -280,30 +289,13 @@ func InferMode(comment string, freqHz int64) string {
 		return "PSK"
 	case strings.Contains(c, "JS8"):
 		return "JS8"
-	case strings.Contains(c, "CW"):
+	// WPM is as good as the word CW: nothing else is reported in words per
+	// minute, and RBN spots carry it on every line.
+	case strings.Contains(c, "CW"), strings.Contains(c, "WPM"):
 		return "CW"
-	case strings.Contains(c, "SSB") || strings.Contains(c, "USB") || strings.Contains(c, "LSB") || strings.Contains(c, "PH"):
+	case strings.Contains(c, "SSB"), strings.Contains(c, "USB"),
+		strings.Contains(c, "LSB"), strings.Contains(c, "PH"):
 		return "SSB"
 	}
-	khz := float64(freqHz) / 1000
+	return modeFromFrequency(freqHz)
-	// FT8 watering holes (…074) and FT4 (…080/…140) as a fallback.
-	for _, f := range []float64{1840, 3573, 7074, 10136, 14074, 18100, 21074, 24915, 28074, 50313} {
-		if khz >= f-1 && khz <= f+3 {
-			return "FT8"
-		}
-	}
-	// Band-plan CW segments (bottom of each band).
-	switch {
-	case khz >= 1810 && khz <= 1840,
-		khz >= 3500 && khz <= 3570,
-		khz >= 7000 && khz <= 7040,
-		khz >= 10100 && khz <= 10130,
-		khz >= 14000 && khz <= 14070,
-		khz >= 18068 && khz <= 18095,
-		khz >= 21000 && khz <= 21070,
-		khz >= 24890 && khz <= 24910,
-		khz >= 28000 && khz <= 28070:
-		return "CW"
-	}
-	return "SSB"
 }

internal/alerts/bandplan.go

@@ -0,0 +1,76 @@
+package alerts
+
+// The band plan behind InferMode, and why it is written out segment by segment.
+//
+// A cluster line carries no mode, so it has to be inferred — and OpsLog was
+// inferring it TWICE, in two places, from two different tables. The frontend
+// knew that 10.130-10.150 is the 30 m data segment; this side only knew a CW
+// range that stopped at 10.130 and called everything after it SSB. So a spot at
+// 10131.5 showed as DATA in the cluster list and raised an alert saying SSB.
+// Reported with a screenshot of exactly that, on RI1FJL.
+//
+// The two tables are now the same table, transcribed from the frontend's
+// (frontend/src/lib/spot.ts) with its segment boundaries kept intact. They stay
+// two files because they are two languages, and the test next door is what
+// keeps them one answer.
+
+// modeSeg is one stretch of a band, in Hz, and what is worked there.
+type modeSeg struct {
+	loHz, hiHz int64
+	mode       string
+}
+
+// bandPlan is scanned IN ORDER, so a narrow watering hole listed before the
+// wide segment it sits inside wins — FT8 at 14.074 before the 14.070-14.100
+// data block. Order is the whole mechanism here; sorting this table by
+// frequency would quietly turn every FT8 hole into "DATA".
+var bandPlan = []modeSeg{
+	{1_800_000, 1_838_000, "CW"}, {1_838_000, 1_840_000, "FT8"}, {1_840_000, 2_000_000, "SSB"},
+
+	{3_573_000, 3_576_000, "FT8"}, {3_500_000, 3_580_000, "CW"},
+	{3_580_000, 3_600_000, "DATA"}, {3_600_000, 4_000_000, "SSB"},
+
+	{5_300_000, 5_500_000, "SSB"},
+
+	{7_074_000, 7_077_000, "FT8"}, {7_047_500, 7_048_500, "FT4"},
+	{7_000_000, 7_040_000, "CW"}, {7_040_000, 7_100_000, "DATA"}, {7_100_000, 7_300_000, "SSB"},
+
+	// 30 m: CW to 10.130, data above it — and nothing else. No SSB on this band.
+	{10_100_000, 10_130_000, "CW"}, {10_130_000, 10_150_000, "DATA"},
+
+	{14_074_000, 14_077_000, "FT8"}, {14_080_000, 14_081_500, "FT4"},
+	{14_000_000, 14_070_000, "CW"}, {14_070_000, 14_100_000, "DATA"}, {14_100_000, 14_350_000, "SSB"},
+
+	{18_100_000, 18_103_000, "FT8"},
+	{18_068_000, 18_095_000, "CW"}, {18_095_000, 18_110_000, "DATA"}, {18_110_000, 18_168_000, "SSB"},
+
+	{21_074_000, 21_077_000, "FT8"}, {21_140_000, 21_143_000, "FT4"},
+	{21_000_000, 21_070_000, "CW"}, {21_070_000, 21_150_000, "DATA"}, {21_150_000, 21_450_000, "SSB"},
+
+	{24_915_000, 24_917_000, "FT8"},
+	{24_890_000, 24_915_000, "CW"}, {24_915_000, 24_940_000, "DATA"}, {24_940_000, 24_990_000, "SSB"},
+
+	{28_074_000, 28_077_000, "FT8"}, {28_180_000, 28_183_000, "FT4"},
+	{28_000_000, 28_070_000, "CW"}, {28_070_000, 28_300_000, "DATA"}, {28_300_000, 29_700_000, "SSB"},
+
+	{50_313_000, 50_316_000, "FT8"}, {50_318_000, 50_321_000, "FT4"},
+	{50_000_000, 50_100_000, "CW"}, {50_100_000, 50_500_000, "SSB"},
+
+	{144_174_000, 144_177_000, "FT8"},
+	{144_000_000, 144_150_000, "CW"}, {144_150_000, 144_500_000, "SSB"},
+}
+
+// modeFromFrequency returns what the band plan says is worked at freqHz, or ""
+// where it says nothing.
+//
+// Empty rather than a guess: a spot outside every listed segment is on a band
+// this table does not cover, and answering "SSB" for it is how a 30 m data spot
+// came to raise an SSB alert.
+func modeFromFrequency(freqHz int64) string {
+	for _, s := range bandPlan {
+		if freqHz >= s.loHz && freqHz < s.hiHz {
+			return s.mode
+		}
+	}
+	return ""
+}

internal/alerts/bandplan_test.go

@@ -0,0 +1,71 @@
+package alerts
+
+import "testing"
+
+// The spot that started it: RI1FJL on 10131.5, an FT8 station in the 30 m data
+// segment. The cluster list showed DATA and the alert announced SSB, because
+// this side's table stopped its CW range at 10.130 and called everything above
+// it phone.
+func TestInferModeDoesNotCallThirtyMetresSSB(t *testing.T) {
+	if got := InferMode("", 10_131_500); got != "DATA" {
+		t.Errorf("10131.5 kHz → %q, want DATA (there is no SSB on 30 m)", got)
+	}
+	// And the CW half of the same band still reads as CW.
+	if got := InferMode("", 10_110_000); got != "CW" {
+		t.Errorf("10110 kHz → %q, want CW", got)
+	}
+}
+
+// The comment beats the band plan. A spotter who names the mode knows something
+// no table does — an FT8 station calling outside the usual watering hole, a CW
+// operation in a data segment during a contest.
+func TestInferModeTrustsTheCommentFirst(t *testing.T) {
+	cases := map[string]struct {
+		comment string
+		freqHz  int64
+		want    string
+	}{
+		"FT8 said outright":      {"-14 dB FT8", 14_200_000, "FT8"},
+		"CW in a data segment":   {"CW 599", 14_080_000, "CW"},
+		"RBN reports WPM not CW": {"18 dB 25 WPM CQ", 14_080_000, "CW"},
+		"phone below the split":  {"SSB net", 7_010_000, "SSB"},
+	}
+	for name, c := range cases {
+		t.Run(name, func(t *testing.T) {
+			if got := InferMode(c.comment, c.freqHz); got != c.want {
+				t.Errorf("InferMode(%q, %d) = %q, want %q", c.comment, c.freqHz, got, c.want)
+			}
+		})
+	}
+}
+
+// The watering holes are listed before the wide data blocks they sit inside, and
+// the table is scanned in order — so sorting it by frequency would quietly turn
+// every FT8 hole into "DATA". This is what would fail if somebody did.
+func TestBandPlanKeepsTheWateringHolesAheadOfTheDataBlocks(t *testing.T) {
+	holes := map[int64]string{
+		3_573_500:  "FT8",
+		7_074_500:  "FT8",
+		7_048_000:  "FT4",
+		14_074_500: "FT8",
+		14_080_500: "FT4",
+		21_074_500: "FT8",
+		28_074_500: "FT8",
+		50_313_500: "FT8",
+	}
+	for hz, want := range holes {
+		if got := modeFromFrequency(hz); got != want {
+			t.Errorf("%d Hz → %q, want %q", hz, got, want)
+		}
+	}
+}
+
+// Nothing is claimed for a frequency the plan does not cover. Answering "SSB"
+// for whatever fell through is the exact fault this file exists to fix.
+func TestModeFromFrequencyIsSilentWhenItDoesNotKnow(t *testing.T) {
+	for _, hz := range []int64{500_000, 6_000_000, 70_200_000, 432_100_000} {
+		if got := modeFromFrequency(hz); got != "" {
+			t.Errorf("%d Hz → %q, want \"\" (outside the plan)", hz, got)
+		}
+	}
+}

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/audio/rate.go

@@ -0,0 +1,9 @@
+package audio
+
+// RecorderSampleRate is the rate the QSO recorder works in.
+//
+// Exported because a source that is NOT a sound card — the TCI receive stream,
+// the Icom network audio — has to resample into it, and hard-coding 16000 at
+// each of those call sites is how one of them ends up at the wrong speed after
+// this constant is ever changed.
+const RecorderSampleRate = sampleRate

internal/audio/wav.go

@@ -14,6 +14,7 @@ import (
 // any device regardless of its native mix format.
 const (
 	sampleRate    = 16000
+
 	channels      = 1
 	bitsPerSample = 16
 	blockAlign    = channels * bitsPerSample / 8 // bytes per frame (=2)

internal/cat/flex.go

@@ -59,7 +59,7 @@ type Flex struct {
 	meterRawLogged bool         // log the first raw meter-definition status once
 	txRawLogged    bool         // log the first raw transmit status once (field-name audit)
 
-	spotsEnabled    bool           // push cluster spots + manage the panadapter overlay
+	spotsEnabled bool // push cluster spots + manage the panadapter overlay
 	// foreignSpotSeen counts what probeForeignSpot has already reported, so a
 	// skimmer posting all evening cannot turn the log into its own transcript.
 	foreignSpotSeen int

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
+	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

@@ -34,6 +34,20 @@ type TCI struct {
 	OnSpotClick   func(callsign string, freqHz int64)
 	unhandledSeen map[string]bool // log each unknown TCI message type once
 
+	// panel is the control-console state — everything the radio announces about
+	// itself that is not frequency or mode. See tci_panel.go.
+	panel tciPanel
+
+	// audio holds the receive-audio stream — see tci_audio.go. TCI carries it
+	// on this same WebSocket, which is what lets a SunSDR record and decode
+	// 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)
@@ -56,7 +70,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)
@@ -283,6 +304,22 @@ func (t *TCI) ReadState() (RigState, error) {
 	} else {
 		st.FreqHz = t.freqA
 	}
+	// The transmit meters are asked for, not pushed: TX_POWER and TX_SWR are
+	// read-only commands the radio answers when asked, and asking is only worth
+	// anything while it is keyed. Fired and forgotten from here — the answers
+	// arrive on the reader like everything else — and only while transmitting,
+	// so a receiving station pays nothing for a meter nobody is watching.
+	// Keyed by PTT **or** by TUNE. A tune carrier is exactly when the meters
+	// matter most — it is the carrier an operator is watching an SWR on — and
+	// asking only on t.tx left them at zero for the whole tune, because the
+	// radio reports tuning as its own state and not as a transmission.
+	if t.tx || t.panel.st.Tuning {
+		tx := t
+		go func() {
+			_ = tx.send("tx_power;")
+			_ = tx.send("tx_swr;")
+		}()
+	}
 	st.Mode = tciModeToADIF(t.mode, t.digitalDefault)
 	if st.FreqHz > 0 {
 		st.Band = BandFromHz(st.FreqHz)
@@ -330,9 +367,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()
@@ -341,6 +418,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)
@@ -354,10 +433,18 @@ func (t *TCI) send(cmd string) error {
 // connection closes.
 func (t *TCI) reader(conn *websocket.Conn) {
 	for {
-		_, data, err := conn.ReadMessage()
+		mt, data, err := conn.ReadMessage()
 		if err != nil {
 			break
 		}
+		// TEXT frames are commands, BINARY frames are streams. The type used to
+		// be ignored and every frame split on ';' — harmless only for as long as
+		// no stream was ever opened, since audio bytes would then have been fed
+		// to the command parser a hundred times a second.
+		if wsMessageIsBinary(mt) {
+			t.handleBinary(data)
+			continue
+		}
 		// A frame may carry several ";"-terminated commands.
 		for _, cmd := range strings.Split(string(data), ";") {
 			t.handle(strings.TrimSpace(cmd))
@@ -390,9 +477,32 @@ func (t *TCI) handle(msg string) {
 	}
 	t.mu.Lock()
 	defer t.mu.Unlock()
-	switch strings.ToLower(name) {
+	lower := strings.ToLower(name)
+	// The console's own messages first. Most of them were being logged once as
+	// unhandled and thrown away — the radio has been announcing its drive, its
+	// filters and its noise blanker since the first connection.
+	if t.handlePanel(lower, get, args) {
+		// Still falls through for the few the rig state also needs (split, tune),
+		// which is why this does not return.
+		switch lower {
+		case "split_enable", "trx", "modulation", "vfo":
+		default:
+			return
+		}
+	}
+	switch lower {
 	case "device":
 		t.device = strings.TrimSpace(args)
+	// The radio ANNOUNCES its audio format at connect —
+	// "audio_stream_sample_type:float32" and "audio_stream_channels:2" — which
+	// is better evidence than anything derived from a frame, and it arrives
+	// before the first frame does. Both were being logged as unhandled.
+	case "audio_stream_sample_type":
+		t.audio.declaredType = strings.TrimSpace(args)
+	case "audio_stream_channels":
+		if n, err := strconv.Atoi(strings.TrimSpace(args)); err == nil && n > 0 && n <= 8 {
+			t.audio.declaredChans = n
+		}
 	case "ready", "start":
 		t.ready = true
 	case "stop":
@@ -421,7 +531,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" {
@@ -432,7 +557,7 @@ func (t *TCI) handle(msg string) {
 			t.txAllowed, t.txAllowedKnown = allowed, true
 		}
 	default:
-		lname := strings.ToLower(name)
+		lname := lower
 		// A click on one of our panorama spots comes back as
 		//   CLICKED_ON_SPOT:<call>,<hz>              (legacy)
 		//   RX_CLICKED_ON_SPOT:<rx>,<ch>,<call>,<hz>

internal/cat/tci_audio.go

@@ -0,0 +1,424 @@
+//go:build windows
+
+package cat
+
+// TCI audio — receiving the radio's audio over the same WebSocket that carries
+// the commands, so a SunSDR needs no virtual audio cable.
+//
+// TCI mixes two kinds of frame on one socket: TEXT frames are the commands
+// ("trx:0,true;"), BINARY frames are streams. A binary frame is a fixed header
+// followed by float32 samples:
+//
+//	uint32 receiver     which receiver the stream belongs to
+//	uint32 sampleRate   Hz
+//	uint32 format       0 = float32
+//	uint32 codec        0 = uncompressed
+//	uint32 crc          unused in practice
+//	uint32 length       samples in the payload
+//	uint32 type         which stream this is (see tciStream*)
+//	uint32 reserved[9]
+//	float32 payload[…]  stereo, interleaved
+//
+// The stream is asked for with "audio_samplerate:" then "audio_start:<rx>;",
+// and stopped with "audio_stop:<rx>;".
+//
+// NOTHING HERE IS CONFIRMED ON A RADIO YET. The layout above is read from the
+// TCI documentation, and the stream-type numbers in particular are the sort of
+// detail a document gets right and a memory of it does not — so every header is
+// logged for the first few seconds of a session, and the numbers the radio
+// actually sends will settle it. Same discipline as the Yaesu meters and the
+// Flex spot feed: measure on the real thing, then write the constant down.
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// TCI stream types. RX audio is the one this file consumes; the others are
+// named so a log line says what arrived rather than "type 3".
+const (
+	tciStreamIQ       = 0
+	tciStreamRXAudio  = 1
+	tciStreamTXAudio  = 2
+	tciStreamTXChrono = 3
+)
+
+// tciHeaderWords is the header length in uint32 words (7 named + 9 reserved).
+const tciHeaderWords = 16
+
+// tciHeaderBytes is the same in bytes.
+const tciHeaderBytes = tciHeaderWords * 4
+
+// tciAudioProbeMax bounds the header logging. Enough frames to see the shape
+// and the rate; few enough that an evening of listening does not fill the log.
+const tciAudioProbeMax = 40
+
+// TCIAudioStatus is what the panel polls while testing the stream.
+type TCIAudioStatus struct {
+	Running    bool  `json:"running"`
+	SampleRate int   `json:"sample_rate"`
+	Frames     int64 `json:"frames"`  // binary frames accepted
+	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"`
+	LastErr string  `json:"last_err,omitempty"`
+}
+
+// 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
+	want        bool // the host asked for audio
+	rx          int  // which receiver
+	rate        int
+	frames      int64
+	samples     int64
+	peak        float64
+	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
+	// than as the only source.
+	declaredType  string
+	declaredChans int
+
+	// OnSamples receives decoded MONO samples (the two channels averaged) at
+	// the negotiated rate. Mono because everything downstream — the QSO
+	// recorder, the CW decoder — works on one channel, and a receiver's two
+	// channels carry the same audio.
+	OnSamples func(rate int, samples []float32)
+}
+
+// StartTCIAudio asks the radio to stream receiver rx's audio.
+func (t *TCI) StartTCIAudio(rx, rate int) error {
+	if rate <= 0 {
+		rate = 48000
+	}
+	t.audio.mu.Lock()
+	t.audio.want = true
+	t.audio.rx = rx
+	t.audio.rate = rate
+	t.audio.frames, t.audio.samples, t.audio.peak = 0, 0, 0
+	t.audio.lastErr = ""
+	t.audio.mu.Unlock()
+
+	// Sample rate first: the radio applies it to the stream it is about to
+	// open, and asking afterwards restarts the stream on some firmware.
+	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))
+}
+
+// SetTCIAudioSink installs (or removes) the consumer of the decoded samples.
+//
+// One sink, not a list: today it is a test recording, tomorrow the QSO
+// recorder, and two consumers of a live stream would need a policy about which
+// one wins that nothing yet has an opinion about.
+func (t *TCI) SetTCIAudioSink(fn func(rate int, samples []float32)) {
+	t.audio.mu.Lock()
+	t.audio.OnSamples = fn
+	t.audio.mu.Unlock()
+}
+
+// StopTCIAudio closes the stream.
+func (t *TCI) StopTCIAudio() error {
+	t.audio.mu.Lock()
+	t.audio.want = false
+	rx := t.audio.rx
+	t.audio.mu.Unlock()
+	return t.send(fmt.Sprintf("audio_stop:%d;", rx))
+}
+
+// TCIAudioStatus reports what has arrived.
+func (t *TCI) TCIAudioStatus() TCIAudioStatus {
+	t.audio.mu.Lock()
+	defer t.audio.mu.Unlock()
+	st := TCIAudioStatus{
+		Running:    t.audio.want,
+		SampleRate: t.audio.rate,
+		Frames:     t.audio.frames,
+		Samples:    t.audio.samples,
+		LastErr:    t.audio.lastErr,
+	}
+	// A peak older than a second is not a level, it is a memory. Reported as
+	// silence rather than left standing, so a stream that has stopped arriving
+	// looks stopped.
+	if time.Since(t.audio.peakAt) < time.Second && t.audio.peak > 0 {
+		st.PeakDB = 20 * math.Log10(t.audio.peak)
+	} else {
+		st.PeakDB = -99
+	}
+	return st
+}
+
+// handleBinary decodes one binary WebSocket frame.
+//
+// Called from the reader goroutine. Anything malformed is counted and dropped:
+// a stream frame is not worth breaking the command connection over, and the
+// command connection is what keeps the radio usable.
+func (t *TCI) handleBinary(data []byte) {
+	if len(data) < tciHeaderBytes {
+		t.audioErr(fmt.Sprintf("binary frame of %d bytes is shorter than a header", len(data)))
+		return
+	}
+	le := binary.LittleEndian
+	receiver := int(le.Uint32(data[0:]))
+	rate := int(le.Uint32(data[4:]))
+	format := le.Uint32(data[8:])
+	codec := le.Uint32(data[12:])
+	length := int(le.Uint32(data[20:]))
+	stype := int(le.Uint32(data[24:]))
+
+	// Counted PER STREAM TYPE, not overall.
+	//
+	// A single counter was spent on the first forty receive-audio frames, which
+	// arrive twenty-four times a second — so a transmit-chrono or transmit-audio
+	// frame, the two this needs to see before the voice keyer can be written,
+	// would never have been logged at all. They only appear once the operator
+	// keys the radio, long after any global budget is gone.
+	t.audio.mu.Lock()
+	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]++
+	}
+	t.audio.mu.Unlock()
+	if probe < tciAudioProbeMax {
+		debugLog.Printf("TCI: binary frame — rx=%d rate=%d format=%d codec=%d length=%d type=%d payload=%d bytes",
+			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 and transmit audio. The latter is ours to send, not to receive:
+		// counted above, and dropped.
+		return
+	}
+	if codec != 0 {
+		t.audioErr(fmt.Sprintf("stream is codec=%d, and nothing here decodes a compressed stream", codec))
+		return
+	}
+
+	// The FORMAT number is decided by measurement, not by the number itself.
+	//
+	// A real SunSDR answered format=3, where the code expected 0 — and 0 was a
+	// guess from reading the documentation, which is exactly the kind of detail
+	// a memory of a document gets wrong. Rather than swap one magic number for
+	// another, the sample width is derived from what arrived: the header says
+	// how many samples the payload holds, so the bytes per sample follow from
+	// dividing. That is true whatever number the format field carries, on this
+	// firmware and the next.
+	payload := data[tciHeaderBytes:]
+	if len(payload) == 0 || length <= 0 {
+		return
+	}
+	width := len(payload) / length
+	var n int
+	switch width {
+	case 4:
+		n = len(payload) / 4 // float32
+	case 2:
+		n = len(payload) / 2 // 16-bit PCM
+	default:
+		t.audioErr(fmt.Sprintf("frame carries %d bytes for %d samples (format=%d) — not a width this reads",
+			len(payload), length, format))
+		return
+	}
+	if n == 0 {
+		return
+	}
+	// Under the lock like the rest of the counters: the reader is the only
+	// writer today, but a fact about the radio that is read from another
+	// goroutine has no business being the one field left unguarded.
+	t.audio.mu.Lock()
+	first := !t.audio.widthLogged
+	t.audio.widthLogged = true
+	t.audio.mu.Unlock()
+	if first {
+		debugLog.Printf("TCI: audio is %d bytes per sample at %d Hz (format field says %d)", width, rate, format)
+	}
+	// Stereo interleaved → mono. Both channels of a receiver carry the same
+	// audio, and everything downstream works on one.
+	// How many channels are interleaved. The radio says so at connect; two is
+	// the fallback, which is what every SunSDR seen so far streams.
+	t.audio.mu.Lock()
+	chans := t.audio.declaredChans
+	t.audio.mu.Unlock()
+	if chans <= 0 {
+		chans = 2
+	}
+	mono := make([]float32, 0, n/chans+1)
+	var peak float64
+	sample := func(i int) float32 {
+		if width == 2 {
+			// 16-bit PCM, scaled to the same -1…1 the rest of the audio path
+			// works in, so a change of format cannot change what a level means.
+			return float32(int16(le.Uint16(payload[i*2:]))) / 32768
+		}
+		return math.Float32frombits(le.Uint32(payload[i*4:]))
+	}
+	for i := 0; i+chans-1 < n; i += chans {
+		var sum float32
+		for c := 0; c < chans; c++ {
+			sum += sample(i + c)
+		}
+		v := sum / float32(chans)
+		if a := math.Abs(float64(v)); a > peak {
+			peak = a
+		}
+		mono = append(mono, v)
+	}
+
+	t.audio.mu.Lock()
+	t.audio.frames++
+	t.audio.samples += int64(len(mono))
+	if rate > 0 {
+		t.audio.rate = rate
+	}
+	if peak > t.audio.peak || time.Since(t.audio.peakAt) > time.Second {
+		t.audio.peak = peak
+		t.audio.peakAt = time.Now()
+	}
+	cb := t.audio.OnSamples
+	t.audio.mu.Unlock()
+
+	if cb != nil {
+		cb(rate, mono)
+	}
+}
+
+// audioErr records a decoding complaint, once, so the panel can show it without
+// the log filling with the same line at fifty frames a second.
+func (t *TCI) audioErr(msg string) {
+	t.audio.mu.Lock()
+	first := t.audio.lastErr != msg
+	t.audio.lastErr = msg
+	t.audio.mu.Unlock()
+	if first {
+		debugLog.Printf("TCI: audio: %s", msg)
+	}
+}
+
+// resumeAudio re-opens the stream after a reconnect, if the host had asked for
+// it. A dropped WebSocket takes the audio with it, and an operator who switched
+// recording on does not expect to switch it on again.
+func (t *TCI) resumeAudio() {
+	t.audio.mu.Lock()
+	want, rx, rate := t.audio.want, t.audio.rx, t.audio.rate
+	t.audio.mu.Unlock()
+	if !want {
+		return
+	}
+	if err := t.StartTCIAudio(rx, rate); err != nil {
+		debugLog.Printf("TCI: re-opening the audio stream failed: %v", err)
+	}
+}
+
+// wsMessageIsBinary keeps the type test in one place — the reader used to
+// 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_manager.go

@@ -0,0 +1,98 @@
+//go:build windows
+
+package cat
+
+import "fmt"
+
+// TCIAudioController is the receive-audio capability of the TCI backend, kept
+// as an interface for the same reason as the Flex and Yaesu ones: the host asks
+// the manager, and a station running something else gets a clear "this backend
+// does not do that" instead of a nil dereference.
+type TCIAudioController interface {
+	StartTCIAudio(rx, rate int) error
+	StopTCIAudio() error
+	TCIAudioStatus() TCIAudioStatus
+}
+
+// TCIAudioState returns the stream's state, or (zero, false) when the active
+// backend is not a TCI radio.
+func (m *Manager) TCIAudioState() (TCIAudioStatus, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if tc, ok := b.(TCIAudioController); ok {
+		return tc.TCIAudioStatus(), true
+	}
+	return TCIAudioStatus{}, false
+}
+
+// TCIAudioDo dispatches an audio command onto the CAT goroutine, like every
+// other backend-specific control.
+func (m *Manager) TCIAudioDo(fn func(TCIAudioController) error) error {
+	return m.exec(func(b Backend) error {
+		tc, ok := b.(TCIAudioController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a TCI radio")
+		}
+		return fn(tc)
+	})
+}
+
+// TCIPanelController is the control console of a TCI radio — everything the
+// panel reads and everything it sets.
+//
+// Listed one by one rather than accepted as *TCI, for the same reason the audio
+// controller is: the manager hands out capabilities, not backends, and a
+// station on OmniRig asking for the TCI console gets a sentence instead of a
+// crash.
+type TCIPanelController interface {
+	TCIPanel() TCIPanelState
+	SetDrive(v int) error
+	SetTuneDrive(v int) error
+	SetMicLevel(v int) error
+	SetVolume(db int) error
+	SetMute(on bool) error
+	SetAGC(mode string) error
+	SetSquelch(on bool) error
+	SetSquelchLevel(v int) error
+	SetNB(on bool) error
+	SetNR(on bool) error
+	SetANF(on bool) error
+	SetAPF(on bool) error
+	SetFilter(lo, hi int) error
+	SetRIT(on bool) error
+	SetXIT(on bool) error
+	SetRITOffset(hz int) error
+	SetXITOffset(hz int) error
+	SetLock(on bool) error
+	SetTune(on bool) error
+}
+
+// TCIPanelState returns the console snapshot, or (zero, false) when the active
+// backend is not a TCI radio.
+//
+// Read WITHOUT going through the CAT goroutine: the state is a cached copy of
+// what the radio pushed, guarded by its own lock, and the panel polls it several
+// times a second. Queueing that behind whatever the poll loop is doing would put
+// the console's smoothness at the mercy of a rig command's timeout.
+func (m *Manager) TCIPanelState() (TCIPanelState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if tc, ok := b.(TCIPanelController); ok {
+		return tc.TCIPanel(), true
+	}
+	return TCIPanelState{}, false
+}
+
+// TCIPanelDo dispatches one console command onto the CAT goroutine, where every
+// other write to the radio goes.
+func (m *Manager) TCIPanelDo(fn func(TCIPanelController) error) error {
+	return m.exec(func(b Backend) error {
+		tc, ok := b.(TCIPanelController)
+		if !ok {
+			return fmt.Errorf("the active CAT backend is not a TCI radio")
+		}
+		return fn(tc)
+	})
+}

internal/cat/tci_panel.go

@@ -0,0 +1,381 @@
+//go:build windows
+
+package cat
+
+// The TCI control panel: what the radio already tells us, gathered up.
+//
+// This is the cheapest panel in OpsLog, and the reason is worth saying. A K3 is
+// asked — every value on its console costs a command and a reply on a serial
+// line, which is why that panel reads its settings in a rotation and its meters
+// only while it is on screen. TCI PUSHES: the radio announces its drive, its
+// volume, its filters, its noise blanker and everything else when a client
+// connects, and again whenever any of them changes, whoever changed it. There
+// is nothing to poll.
+//
+// So this file is mostly a place to PUT what was already arriving and being
+// logged as "(unhandled once)". The setters are the same names sent back the
+// other way, which is how TCI works throughout: one vocabulary, both directions.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// TCIPanelState is the whole console in one snapshot, polled by the frontend.
+//
+// Values the radio has not mentioned keep their zero, which is why the
+// "Known" flags exist for the ones where zero is a real setting: a squelch at 0
+// and a squelch never reported are different, and a panel that cannot tell them
+// apart draws a control that lies until the operator touches it.
+type TCIPanelState struct {
+	Connected bool   `json:"connected"`
+	Device    string `json:"device,omitempty"`   // what the radio calls itself
+	Protocol  string `json:"protocol,omitempty"` // "ExpertSDR3,1.5"
+
+	// Transmit.
+	Drive     int  `json:"drive"`      // 0-100
+	TuneDrive int  `json:"tune_drive"` // 0-100, used by TUNE
+	MicLevel  int  `json:"mic_level"`  // 0-100
+	TXEnabled bool `json:"tx_enabled"` // the radio's own permission (tx_enable)
+	TX        bool `json:"tx"`
+	Tuning    bool `json:"tuning"`
+
+	// Receive.
+	Volume    int    `json:"volume"` // dB, negative — TCI's own scale
+	Mute      bool   `json:"mute"`
+	AGC       string `json:"agc,omitempty"` // off/long/slow/med/fast
+	SquelchOn bool   `json:"squelch_on"`
+	Squelch   int    `json:"squelch"` // dBm threshold
+	NB        bool   `json:"nb"`
+	NR        bool   `json:"nr"`
+	ANF       bool   `json:"anf"`
+	APF       bool   `json:"apf"`
+
+	// Filter edges in Hz, relative to the carrier (TCI's own convention).
+	FilterLo int `json:"filter_lo"`
+	FilterHi int `json:"filter_hi"`
+
+	// Tuning aids.
+	RIT       bool `json:"rit"`
+	RITOffset int  `json:"rit_offset"`
+	XIT       bool `json:"xit"`
+	XITOffset int  `json:"xit_offset"`
+	Lock      bool `json:"lock"`
+	Split     bool `json:"split"`
+
+	// SMeter is the last reported signal level in dBm — the radio pushes it
+	// several times a second while receiving.
+	SMeter int `json:"smeter"`
+
+	// TXPowerW and TXSWR are the transmit meters. READ-ONLY in TCI, and only
+	// answered while transmitting — asked for on every poll of a keyed radio,
+	// see ReadState.
+	//
+	// There is no temperature in this protocol. The command list has TX_POWER
+	// and TX_SWR and nothing thermal at all, so a temperature reading here would
+	// have to be invented, and an invented temperature on a transmitter is the
+	// kind of number somebody trusts.
+	TXPowerW float64 `json:"tx_power_w"`
+	TXSWR    float64 `json:"tx_swr"`
+
+	// Modulations is what this radio will accept, straight from its own
+	// announcement, so the mode buttons are the radio's and not a guess.
+	Modulations []string `json:"modulations,omitempty"`
+}
+
+// tciPanel is the backing state. Guarded by TCI.mu with everything else it
+// arrives alongside.
+type tciPanel struct {
+	st TCIPanelState
+	// logged counts what has been written per message type — see handlePanel.
+	logged map[string]int
+}
+
+// handlePanel takes the messages the console cares about.
+//
+// Returns false when the message is none of its business, so the caller can go
+// on to its own cases and to the unknown-message log. Called with t.mu held.
+func (t *TCI) handlePanel(name string, get func(int) string, args string) bool {
+	// Most of these are per-receiver ("sql_level:0,20"), and OpsLog follows
+	// receiver 0 throughout. A message for another receiver is accepted as
+	// handled and dropped: it is understood, it is simply not ours.
+	forRX0 := func() bool { return get(0) == "0" || get(0) == "" }
+	num := func(s string) (int, bool) {
+		n, err := strconv.Atoi(strings.TrimSpace(s))
+		return n, err == nil
+	}
+	yes := func(s string) bool { return strings.EqualFold(strings.TrimSpace(s), "true") }
+
+	p := &t.panel.st
+	// Mute and squelch are LOGGED as they change, because a report from a real
+	// radio says pressing MUTE lights the squelch and nothing here can explain
+	// it. What the radio actually announces after the command settles whether
+	// this is our reading or its doing, and no amount of reasoning will.
+	switch name {
+	case "mute", "sql_enable", "sql_level", "tx_power", "tx_swr", "tune":
+		// Logged on arrival so an ANSWER can be told from a SILENCE: the log
+		// showed the transmit meters being asked for and nothing coming back,
+		// which on its own proves nothing — a reply that arrived and failed to
+		// parse leaves exactly the same trace as one that never came.
+		//
+		// Capped per message type. The meters are asked for four times a second
+		// while transmitting, and a diagnostic that fills an evening's log is
+		// one that gets switched off instead of read.
+		if t.panel.logged == nil {
+			t.panel.logged = map[string]int{}
+		}
+		if n := t.panel.logged[name]; n < 20 {
+			t.panel.logged[name] = n + 1
+			debugLog.Printf("TCI: %s:%s", name, args)
+		}
+	}
+	switch name {
+	case "protocol":
+		p.Protocol = strings.TrimSpace(args)
+	case "drive":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.Drive = n
+		} else if n, ok := num(get(0)); ok && get(1) == "" {
+			// Some firmware sends "drive:85" with no receiver index.
+			p.Drive = n
+		}
+	case "tune_drive":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.TuneDrive = n
+		} else if n, ok := num(get(0)); ok && get(1) == "" {
+			p.TuneDrive = n
+		}
+	case "mic_level":
+		if n, ok := num(get(0)); ok {
+			p.MicLevel = n
+		}
+	case "volume":
+		if n, ok := num(get(0)); ok {
+			p.Volume = n
+		}
+	case "mute":
+		// Both shapes. This radio reports "mute:0,false" and the reference shows
+		// "mute:true" elsewhere — reading only one of them left the button
+		// showing the opposite of the truth, which is worse than showing
+		// nothing.
+		if get(1) != "" {
+			p.Mute = yes(get(1))
+		} else {
+			p.Mute = yes(get(0))
+		}
+	case "agc_mode":
+		if forRX0() {
+			p.AGC = strings.ToLower(strings.TrimSpace(get(1)))
+		}
+	case "sql_enable":
+		if forRX0() {
+			p.SquelchOn = yes(get(1))
+		}
+	case "sql_level":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.Squelch = n
+		}
+	case "rx_nb_enable":
+		if forRX0() {
+			p.NB = yes(get(1))
+		}
+	case "rx_nr_enable":
+		if forRX0() {
+			p.NR = yes(get(1))
+		}
+	case "rx_anf_enable":
+		if forRX0() {
+			p.ANF = yes(get(1))
+		}
+	case "rx_apf_enable":
+		if forRX0() {
+			p.APF = yes(get(1))
+		}
+	case "rx_filter_band":
+		if forRX0() {
+			if lo, ok := num(get(1)); ok {
+				p.FilterLo = lo
+			}
+			if hi, ok := num(get(2)); ok {
+				p.FilterHi = hi
+			}
+		}
+	case "rit_enable":
+		if forRX0() {
+			p.RIT = yes(get(1))
+		}
+	case "xit_enable":
+		if forRX0() {
+			p.XIT = yes(get(1))
+		}
+	case "rit_offset":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.RITOffset = n
+		}
+	case "xit_offset":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.XITOffset = n
+		}
+	case "lock":
+		if forRX0() {
+			p.Lock = yes(get(1))
+		}
+	case "tx_power":
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(0)), 64); err == nil {
+			p.TXPowerW = v
+		}
+	case "tx_swr":
+		if v, err := strconv.ParseFloat(strings.TrimSpace(get(0)), 64); err == nil {
+			p.TXSWR = v
+		}
+	case "rx_smeter":
+		if n, ok := num(get(1)); ok && forRX0() {
+			p.SMeter = n
+		}
+	case "tune":
+		if forRX0() {
+			p.Tuning = yes(get(1))
+		}
+	case "modulations_list":
+		p.Modulations = splitAndTrim(args)
+	default:
+		return false
+	}
+	return true
+}
+
+// splitAndTrim turns "usb,lsb,cw" into a slice, upper-cased for display.
+func splitAndTrim(s string) []string {
+	parts := strings.Split(s, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if v := strings.ToUpper(strings.TrimSpace(p)); v != "" {
+			out = append(out, v)
+		}
+	}
+	return out
+}
+
+// TCIPanel returns the console snapshot.
+func (t *TCI) TCIPanel() TCIPanelState {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	st := t.panel.st
+	st.Connected = t.conn != nil
+	st.Device = t.device
+	st.TX = t.tx
+	st.Split = t.split
+	st.TXEnabled = t.txAllowed || !t.txAllowedKnown
+	return st
+}
+
+// ── Setters ───────────────────────────────────────────────────────────────
+//
+// Every one of them is a SET in the same vocabulary the radio reports in, and
+// none of them updates the cached state: the radio answers with the new value,
+// and taking its word rather than our own is what keeps the panel honest when a
+// setting is refused, clamped, or changed from the radio's own window a second
+// later.
+
+// SetDrive sets the transmit drive, 0-100.
+//
+// THE TRX INDEX IS PART OF THE COMMAND — "drive:0,15;", not "drive:15;". Sent
+// without it the radio simply ignores it: no error, no answer, the power
+// unchanged. The rule is the one the radio's own reports follow, and it was
+// there to read all along: this radio announces "drive:0,85" at connect.
+func (t *TCI) SetDrive(v int) error { return t.send(fmt.Sprintf("drive:0,%d;", clampTCIPct(v))) }
+
+// SetTuneDrive sets the drive used by TUNE, 0-100. Indexed, like drive.
+func (t *TCI) SetTuneDrive(v int) error {
+	return t.send(fmt.Sprintf("tune_drive:0,%d;", clampTCIPct(v)))
+}
+
+// SetMicLevel sets the microphone gain, 0-100.
+// Mic gain and volume are the two that are NOT indexed — the radio reports
+// them as "mic_level:100" and "volume:-12", with no receiver in front. Sending
+// the shape the radio speaks in is the whole rule here.
+func (t *TCI) SetMicLevel(v int) error { return t.send(fmt.Sprintf("mic_level:%d;", clampTCIPct(v))) }
+
+// SetVolume sets the receive volume in dB. TCI's scale is negative — 0 is full
+// and -60 is inaudible — so this is NOT clamped to a percentage.
+func (t *TCI) SetVolume(db int) error {
+	if db > 0 {
+		db = 0
+	}
+	if db < -60 {
+		db = -60
+	}
+	return t.send(fmt.Sprintf("volume:%d;", db))
+}
+
+// SetMute mutes or unmutes the receiver. Indexed — the radio reports
+// "mute:0,false", and a mute sent without the index goes nowhere.
+func (t *TCI) SetMute(on bool) error { return t.send(fmt.Sprintf("mute:0,%t;", on)) }
+
+// SetAGC picks the AGC speed: off, long, slow, med, fast.
+func (t *TCI) SetAGC(mode string) error {
+	m := strings.ToLower(strings.TrimSpace(mode))
+	switch m {
+	case "off", "long", "slow", "med", "fast":
+	default:
+		return fmt.Errorf("unknown AGC mode %q", mode)
+	}
+	return t.send(fmt.Sprintf("agc_mode:0,%s;", m))
+}
+
+// SetSquelch turns the squelch on or off.
+func (t *TCI) SetSquelch(on bool) error { return t.send(fmt.Sprintf("sql_enable:0,%t;", on)) }
+
+// SetSquelchLevel sets the threshold in dBm.
+func (t *TCI) SetSquelchLevel(v int) error { return t.send(fmt.Sprintf("sql_level:0,%d;", v)) }
+
+// SetNB, SetNR, SetANF, SetAPF switch the receive processing.
+func (t *TCI) SetNB(on bool) error  { return t.send(fmt.Sprintf("rx_nb_enable:0,%t;", on)) }
+func (t *TCI) SetNR(on bool) error  { return t.send(fmt.Sprintf("rx_nr_enable:0,%t;", on)) }
+func (t *TCI) SetANF(on bool) error { return t.send(fmt.Sprintf("rx_anf_enable:0,%t;", on)) }
+func (t *TCI) SetAPF(on bool) error { return t.send(fmt.Sprintf("rx_apf_enable:0,%t;", on)) }
+
+// SetFilter sets the passband edges in Hz.
+func (t *TCI) SetFilter(lo, hi int) error {
+	if lo > hi {
+		lo, hi = hi, lo
+	}
+	return t.send(fmt.Sprintf("rx_filter_band:0,%d,%d;", lo, hi))
+}
+
+// SetRIT / SetXIT switch the offsets on, SetRITOffset / SetXITOffset move them.
+func (t *TCI) SetRIT(on bool) error      { return t.send(fmt.Sprintf("rit_enable:0,%t;", on)) }
+func (t *TCI) SetXIT(on bool) error      { return t.send(fmt.Sprintf("xit_enable:0,%t;", on)) }
+func (t *TCI) SetRITOffset(hz int) error { return t.send(fmt.Sprintf("rit_offset:0,%d;", hz)) }
+func (t *TCI) SetXITOffset(hz int) error { return t.send(fmt.Sprintf("xit_offset:0,%d;", hz)) }
+
+// SetLock locks the VFO knob on the radio.
+func (t *TCI) SetLock(on bool) error { return t.send(fmt.Sprintf("lock:0,%t;", on)) }
+
+// SetTune starts or stops the tune carrier.
+//
+// It TRANSMITS, at tune_drive rather than at drive — which is the setting to
+// check before pressing it, and why the panel shows the two side by side.
+//
+// The state is recorded HERE rather than waited for. This radio does not echo
+// "tune:0,true", so the panel had no way of knowing a tune was running: the
+// button stayed on TUNE and every further press sent another START, which is
+// why it could not be switched off again. Whatever the radio says afterwards
+// still wins — it simply never says anything.
+func (t *TCI) SetTune(on bool) error {
+	t.mu.Lock()
+	t.panel.st.Tuning = on
+	t.mu.Unlock()
+	return t.send(fmt.Sprintf("tune:0,%t;", on))
+}
+
+func clampTCIPct(v int) int {
+	if v < 0 {
+		return 0
+	}
+	if v > 100 {
+		return 100
+	}
+	return v
+}

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/cat/yaesu_panel.go

@@ -51,13 +51,13 @@ type YaesuTXState struct {
 	// NarrowSupported says the rig answered NA at all. A button that reports a
 	// state the radio never gave, and does nothing when pressed, is worse than
 	// an absent one: it looks like a fault in the radio.
-	NarrowSupported bool `json:"narrow_supported"`
+	NarrowSupported bool   `json:"narrow_supported"`
-	MicGain int    `json:"mic_gain"` // 0-100
+	MicGain         int    `json:"mic_gain"` // 0-100
-	AFGain  int    `json:"af_gain"`  // 0-100
+	AFGain          int    `json:"af_gain"`  // 0-100
-	RFGain  int    `json:"rf_gain"`  // 0-100
+	RFGain          int    `json:"rf_gain"`  // 0-100
-	Squelch int    `json:"squelch"`  // 0-100
+	Squelch         int    `json:"squelch"`  // 0-100
-	AGC     string `json:"agc,omitempty"`
+	AGC             string `json:"agc,omitempty"`
-	Preamp  int    `json:"preamp"` // 0=IPO, 1=AMP1, 2=AMP2
+	Preamp          int    `json:"preamp"` // 0=IPO, 1=AMP1, 2=AMP2
 	// Antenna is the selected jack, 1-3, or 0 when the rig has no AN command —
 	// an FT-891 or FT-991A has a single socket and answers nothing. 0 is what
 	// tells the panel to draw no selector at all rather than a dead one.

internal/dxcc/deleted.go

@@ -0,0 +1,97 @@
+package dxcc
+
+// The DELETED DXCC entities, and why a lookup table needs to know about them.
+//
+// cty.dat answers one question: what entity is this callsign in TODAY. That is
+// the right answer for a spot and the wrong one for a log. R1MVI was Malyj
+// Vysotskij Island, entity 151, until the ARRL deleted it in February 2012;
+// today the same callsign resolves to European Russia, 54. A 2004 contact
+// re-stamped from cty.dat therefore loses the entity it was made with — and
+// with it a DXCC credit that cannot be worked again, because the place no
+// longer counts.
+//
+// Reported by an operator importing a Logger32 export: his ADIF said
+// <DXCC:3>151 and OpsLog stored 54.
+//
+// So this list exists to be able to say "that number belongs to something that
+// no longer exists, leave it alone". It is the ADIF specification's own
+// enumeration of deleted entities, and it does not change except when the ARRL
+// deletes another one.
+var deletedEntities = map[int]string{
+	2:   "Abu Ail Is.",
+	8:   "Aldabra",
+	19:  "Bajo Nuevo",
+	23:  "Blenheim Reef",
+	25:  "British North Borneo",
+	26:  "British Somaliland",
+	28:  "Canal Zone",
+	30:  "Celebe & Molucca Is.",
+	39:  "Comoros",
+	42:  "Damao, Diu",
+	44:  "Desroches",
+	55:  "Farquhar",
+	57:  "French Equatorial Africa",
+	58:  "French Indo-China",
+	59:  "French West Africa",
+	67:  "French India",
+	68:  "Kuwait/Saudi Arabia Neutral Zone",
+	81:  "Germany",
+	85:  "Bonaire, Curacao",
+	93:  "Geyser Reef",
+	101: "Goa",
+	102: "Gold Coast, Togoland",
+	113: "Ifni",
+	115: "Italian Somaliland",
+	119: "Java",
+	127: "Kamaran Is.",
+	128: "Karelo-Finnish Republic",
+	134: "Kingman Reef",
+	139: "Kuria Muria I.",
+	151: "Malyj Vysotskij I.",
+	154: "Yemen Arab Republic",
+	155: "Malaya",
+	164: "Manchuria",
+	178: "Minerva Reef",
+	183: "Netherlands Borneo",
+	184: "Netherlands New Guinea",
+	186: "Newfoundland, Labrador",
+	193: "Okinawa (Ryukyu Is.)",
+	194: "Okino Tori-shima",
+	196: "Palestine",
+	200: "Portuguese Timor",
+	208: "Ruanda-Urundi",
+	210: "Saar",
+	218: "Czechoslovakia",
+	220: "Sarawak",
+	226: "Saudi Arabia/Iraq Neutral Zone",
+	228: "Serrana Bank & Roncador Cay",
+	229: "German Democratic Republic",
+	231: "Sikkim",
+	243: "People's Democratic Rep. of Yemen",
+	244: "Southern Sudan",
+	255: "St. Maarten, Saba, St. Eustatius",
+	258: "Sumatra",
+	261: "Swan Is.",
+	264: "Tangier",
+	267: "Territory of New Guinea",
+	268: "Tibet",
+	271: "Trieste",
+	307: "Zanzibar",
+	488: "Walvis Bay",
+	493: "Penguin Is.",
+}
+
+// IsDeleted reports whether a DXCC entity number names an entity the ARRL has
+// deleted.
+//
+// The one thing every caller does with a true answer is the same: stop. A
+// deleted entity cannot be looked up from a callsign, cannot be worked again,
+// and cannot be corrected by anything that only knows about today.
+func IsDeleted(n int) bool {
+	_, ok := deletedEntities[n]
+	return ok
+}
+
+// DeletedName is what entity n was called, or "" if it is not a deleted entity.
+// Used to say WHICH entity was preserved rather than only that one was.
+func DeletedName(n int) string { return deletedEntities[n] }

internal/dxcc/deleted_test.go

@@ -0,0 +1,46 @@
+package dxcc
+
+import "testing"
+
+// The contact that reported this: R1MVI, worked in 2004 on Malyj Vysotskij
+// Island, entity 151, deleted in February 2012. cty.dat resolves that callsign
+// to European Russia (54) today, so anything that re-stamps an old QSO from a
+// callsign has to know to stop here.
+func TestMalyjVysotskijIsKnownDeleted(t *testing.T) {
+	if !IsDeleted(151) {
+		t.Fatal("151 (Malyj Vysotskij I.) must be known as deleted — the whole guard hangs on it")
+	}
+	if got := DeletedName(151); got == "" {
+		t.Error("a deleted entity should be able to say what it was called")
+	}
+}
+
+// The guard must not fire on entities that are alive, or every log would freeze
+// at whatever DXCC number it was imported with — including the wrong ones.
+func TestLiveEntitiesAreNotTreatedAsDeleted(t *testing.T) {
+	live := map[int]string{
+		54:  "European Russia — what R1MVI resolves to today",
+		227: "France",
+		291: "United States",
+		339: "Japan",
+		1:   "Canada",
+	}
+	for n, what := range live {
+		if IsDeleted(n) {
+			t.Errorf("%d (%s) must not be listed as deleted", n, what)
+		}
+	}
+	if got := DeletedName(54); got != "" {
+		t.Errorf("DeletedName(54) = %q, want empty", got)
+	}
+}
+
+// A few more from the ADIF enumeration, so a careless edit to the table is
+// caught rather than discovered by an operator whose credits moved.
+func TestSomeOtherDeletedEntities(t *testing.T) {
+	for _, n := range []int{218 /* Czechoslovakia */, 229 /* German DR */, 255 /* St. Maarten, Saba, St. Eustatius */, 28 /* Canal Zone */} {
+		if !IsDeleted(n) {
+			t.Errorf("%d should be a deleted entity", n)
+		}
+	}
+}

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/kpa/doc.go

@@ -0,0 +1,60 @@
+// Package kpa talks to the Elecraft KPA500 and KPA1500 amplifiers.
+//
+// One package for both: they share the Elecraft command set — ASCII, a caret
+// prefix, a semicolon terminator, case-insensitive on the way in and upper case
+// on the way back — which is the same family as the K3/K4 panel in
+// internal/cat. What differs between the two models is the transport and which
+// commands exist, not the grammar.
+//
+// # Transports
+//
+// KPA500: serial only.
+//
+// KPA1500: serial, and a network server. Four things may be connected AT ONCE,
+// which is unusual enough to design around — the Host PC USB port, the XCVR
+// SERIAL connector when repurposed as a second host, ONE TCP client, and any
+// number of UDP clients:
+//
+//   - TCP on port 1500 (changed with ^CP). Single client. If the operator
+//     already has the Elecraft utility or another program on TCP, OpsLog will
+//     not get in, and the failure is a refused connection rather than anything
+//     the amplifier says.
+//   - UDP on the same port. Many clients, one command per packet and at most
+//     one response, and packets may be dropped under congestion — so it is the
+//     right choice for sharing the amplifier and the wrong one for a command
+//     that must not be missed.
+//
+// # Pacing
+//
+// There is NO flow control. The reference is explicit: pace commands by waiting
+// for the response to the previous one. So this client is strictly
+// question-and-answer on one connection, like the ACOM and SPE clients, rather
+// than firing a poll cycle and sorting out the replies afterwards.
+//
+// # Serial speed
+//
+// 4800 to 230400, 8N1, set on the amplifier (^BR / SERIAL SPEED HOST) and not
+// negotiated. Elecraft's own utility finds it by sending bare semicolons at
+// each speed until something answers — worth copying if operators turn up with
+// amplifiers whose speed they do not know.
+//
+// # What is settled, and how
+//
+// From the KPA1500 Programming Reference:
+//
+//   - ^SW is the SWR IN TENTHS. "123 is 12.3:1", so ^SW015 is 1.5:1. This was
+//     first taken from Hamlib's backend and is now confirmed by the document,
+//     which matters more than it sounds: a wrongly scaled SWR bar reports a
+//     good match on a bad antenna.
+//   - ^WS returns forward power AND SWR together, ^VI returns PA voltage AND
+//     current together. Two round trips instead of four on the link the display
+//     depends on while the operator is transmitting.
+//   - ^SF returns the fault log: index, fault code, a short name in quotes, a
+//     timestamp, and fault-specific values. ^FC describes the codes.
+//
+// # Not touched
+//
+// ^TX simulates a KEY IN — it makes the amplifier transmit from software — and
+// ^ON0 switches the main supplies off. Neither belongs on a poll loop or behind
+// a button that can be pressed by accident.
+package kpa

internal/kpa/kpa.go

@@ -0,0 +1,412 @@
+package kpa
+
+// The client: one connection, strict question-and-answer, a cached status.
+//
+// Shaped like internal/acom and internal/spe so a third amplifier is the same
+// thing to read — but the traffic is the opposite kind. Those two are told to
+// stream and are then listened to; this one is asked, and answers. The
+// reference is explicit that there is no flow control and that commands are
+// paced by waiting for the previous reply, so nothing here ever has two
+// questions outstanding.
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"go.bug.st/serial"
+
+	"hamlog/internal/applog"
+)
+
+const (
+	dialTimeout = 5 * time.Second
+	ioTimeout   = 2 * time.Second
+	// pollInterval is the fast cycle: forward power, SWR, and whether a fault has
+	// appeared. Four times a second is enough for a bar that is read while
+	// talking, and it is four round trips a second on a link with no flow
+	// control — faster buys nothing and costs the set commands their latency.
+	pollInterval = 250 * time.Millisecond
+	// slowEvery is how many fast cycles pass between the readings that do not
+	// move: mode, band, temperature, supply. Once a second.
+	slowEvery = 4
+)
+
+// Status is what the panel polls.
+type Status struct {
+	Connected bool   `json:"connected"`
+	Transport string `json:"transport"` // "serial" | "tcp"
+	Model     string `json:"model,omitempty"`
+	LastError string `json:"last_error,omitempty"`
+
+	// PowerOn is the main supplies (^ON), Operate is OPERATE vs STANDBY (^OS).
+	// They are different questions: an amplifier can be switched on and in
+	// standby, which is the normal state between overs.
+	PowerOn bool `json:"power_on"`
+	Operate bool `json:"operate"`
+
+	FwdW  int     `json:"fwd_w"`
+	SWR   float64 `json:"swr"`
+	VoltV float64 `json:"volt_v"`
+	CurA  int     `json:"cur_a"`
+	TempC int     `json:"temp_c"`
+	Band  string  `json:"band,omitempty"`
+
+	// Tuning is the ATU mid-cycle (^TP), so a panel can say so rather than
+	// showing a wild SWR and a power reading nobody should act on.
+	Tuning bool `json:"tuning"`
+
+	// Fault is the current fault code and its meaning. A fault puts the
+	// amplifier in STANDBY by itself, so it is the first thing to show.
+	FaultCode int    `json:"fault_code"`
+	FaultText string `json:"fault_text,omitempty"`
+}
+
+// Config selects the model and how to reach it.
+type Config struct {
+	Model     string // "KPA500" | "KPA1500"
+	Transport string // "serial" | "tcp"
+	ComPort   string // serial
+	Baud      int    // serial: 4800…230400, set on the amplifier and not negotiated
+	Host      string // tcp (KPA1500 only)
+	Port      int    // tcp, default 1500
+}
+
+type Client struct {
+	cfg Config
+
+	mu   sync.Mutex // serialises the connection: one question at a time
+	conn io.ReadWriteCloser
+	rd   *bufio.Reader
+
+	statusMu sync.RWMutex
+	status   Status
+
+	stop    chan struct{}
+	running bool
+}
+
+// New builds a client. Nothing is opened until Start.
+func New(cfg Config) *Client {
+	if cfg.Baud <= 0 {
+		cfg.Baud = 38400
+	}
+	if cfg.Port <= 0 {
+		cfg.Port = 1500
+	}
+	if strings.TrimSpace(cfg.Model) == "" {
+		cfg.Model = "KPA1500"
+	}
+	c := &Client{cfg: cfg, stop: make(chan struct{})}
+	c.status.Transport = cfg.Transport
+	c.status.Model = strings.ToUpper(strings.TrimSpace(cfg.Model))
+	return c
+}
+
+func (c *Client) Start() error {
+	if c.running {
+		return nil
+	}
+	c.running = true
+	go c.pollLoop()
+	return nil
+}
+
+func (c *Client) Stop() {
+	if !c.running {
+		return
+	}
+	c.running = false
+	close(c.stop)
+	c.mu.Lock()
+	c.dropLocked()
+	c.mu.Unlock()
+}
+
+func (c *Client) GetStatus() Status {
+	c.statusMu.RLock()
+	defer c.statusMu.RUnlock()
+	return c.status
+}
+
+func (c *Client) setErr(msg string) {
+	c.statusMu.Lock()
+	was := c.status.LastError
+	c.status.Connected = false
+	c.status.LastError = msg
+	c.statusMu.Unlock()
+	// Logged on CHANGE only: a disconnected amplifier is polled four times a
+	// second, and the log is where a hardware problem is diagnosed hours later.
+	if msg != "" && msg != was {
+		applog.Printf("kpa: %s", msg)
+	}
+}
+
+// dropLocked closes the connection. Caller holds c.mu.
+func (c *Client) dropLocked() {
+	if c.conn != nil {
+		_ = c.conn.Close()
+		c.conn = nil
+		c.rd = nil
+	}
+}
+
+// connectLocked opens the transport. Caller holds c.mu.
+func (c *Client) connectLocked() error {
+	if c.conn != nil {
+		return nil
+	}
+	switch strings.ToLower(strings.TrimSpace(c.cfg.Transport)) {
+	case "tcp":
+		if strings.TrimSpace(c.cfg.Host) == "" {
+			return fmt.Errorf("no address configured for the amplifier")
+		}
+		addr := net.JoinHostPort(c.cfg.Host, fmt.Sprint(c.cfg.Port))
+		conn, err := net.DialTimeout("tcp", addr, dialTimeout)
+		if err != nil {
+			// Named for what it usually is. The KPA1500 accepts ONE TCP client,
+			// so the common failure is not a wrong address but the Elecraft
+			// utility already holding the socket — and "connection refused"
+			// sends an operator looking at their network instead.
+			return fmt.Errorf("cannot reach the amplifier on %s: %w (it accepts a single TCP connection — close the Elecraft utility or any other program using it)", addr, err)
+		}
+		c.conn = conn
+	default:
+		if strings.TrimSpace(c.cfg.ComPort) == "" {
+			return fmt.Errorf("no serial port configured for the amplifier")
+		}
+		p, err := serial.Open(c.cfg.ComPort, &serial.Mode{BaudRate: c.cfg.Baud})
+		if err != nil {
+			return fmt.Errorf("cannot open %s: %w", c.cfg.ComPort, err)
+		}
+		_ = p.SetReadTimeout(ioTimeout)
+		c.conn = p
+	}
+	c.rd = bufio.NewReader(c.conn)
+	applog.Printf("kpa: connected to the %s", c.status.Model)
+	return nil
+}
+
+// ask sends one command and reads its answer.
+//
+// The whole exchange is under the lock: with no flow control, two questions in
+// flight means two answers to sort out, and the only thing distinguishing them
+// is the prefix — which is exactly what payload() has to reject when it
+// happens.
+func (c *Client) ask(cmd string) (string, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if err := c.connectLocked(); err != nil {
+		return "", err
+	}
+	if tc, ok := c.conn.(net.Conn); ok {
+		_ = tc.SetDeadline(time.Now().Add(ioTimeout))
+	}
+	if _, err := c.conn.Write([]byte(cmd)); err != nil {
+		c.dropLocked()
+		return "", fmt.Errorf("writing %s: %w", cmd, err)
+	}
+	// Answers end with a semicolon and nothing else does, so the terminator is
+	// the frame.
+	line, err := c.rd.ReadString(';')
+	if err != nil {
+		c.dropLocked()
+		return "", fmt.Errorf("no answer to %s: %w", cmd, err)
+	}
+	return strings.TrimSpace(line), nil
+}
+
+// send is a SET: written, and not answered. The reference says SET commands do
+// not generally produce a response, so waiting for one would stall the poll
+// loop for a whole timeout every time the operator pressed a button.
+func (c *Client) send(cmd string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if err := c.connectLocked(); err != nil {
+		return err
+	}
+	if tc, ok := c.conn.(net.Conn); ok {
+		_ = tc.SetDeadline(time.Now().Add(ioTimeout))
+	}
+	if _, err := c.conn.Write([]byte(cmd)); err != nil {
+		c.dropLocked()
+		return fmt.Errorf("writing %s: %w", cmd, err)
+	}
+	applog.Printf("kpa: → %s", cmd)
+	return nil
+}
+
+// Operate puts the amplifier in OPERATE (true) or STANDBY (false).
+//
+// Worth knowing, and worth saying in the UI: from firmware 01.41 onwards,
+// going to OPERATE also CLEARS the current fault — every one except
+// temperature, which clears by cooling. So this button is the way out of a
+// fault as well as the way into transmit.
+func (c *Client) Operate(on bool) error {
+	if on {
+		return c.send("^OS1;")
+	}
+	return c.send("^OS0;")
+}
+
+// ClearFault clears the current fault without changing mode (^FLC).
+func (c *Client) ClearFault() error { return c.send("^FLC;") }
+
+// PowerOn switches the main supplies on or off (^ON1 / ^ON0).
+//
+// Off is a real power-down, not standby, and the way back on over the network
+// is Wake-on-LAN or the front panel — so a caller should be asking the operator
+// first. The sleeping microcontroller does answer ^ON while the supplies are
+// off, which is why "off" is a state this can report rather than a silence.
+func (c *Client) PowerOn(on bool) error {
+	if on {
+		return c.send("^ON1;")
+	}
+	return c.send("^ON0;")
+}
+
+// Tune starts an ATU tune cycle (^FT). It needs drive from the transceiver.
+func (c *Client) Tune() error { return c.send("^FT;") }
+
+// pollLoop keeps the status fresh, reconnecting as needed.
+func (c *Client) pollLoop() {
+	t := time.NewTicker(pollInterval)
+	defer t.Stop()
+	var n uint64
+	for {
+		select {
+		case <-c.stop:
+			return
+		case <-t.C:
+			c.pollOnce(n)
+			n++
+		}
+	}
+}
+
+func (c *Client) pollOnce(n uint64) {
+	// Forward power and SWR in ONE exchange (^WS), which is why that command
+	// exists and why the two are not asked separately.
+	reply, err := c.ask("^WS;")
+	if err != nil {
+		c.setErr(err.Error())
+		return
+	}
+	w, swr, err := parseWS(reply)
+	if err != nil {
+		c.setErr(err.Error())
+		return
+	}
+
+	c.statusMu.Lock()
+	c.status.Connected = true
+	c.status.LastError = ""
+	c.status.FwdW, c.status.SWR = w, swr
+	c.statusMu.Unlock()
+
+	// The fault, every cycle: it puts the amplifier in standby by itself, and an
+	// operator watching a power bar needs to know why it stopped moving.
+	if reply, err := c.ask("^FL;"); err == nil {
+		if code, err := parseFault(reply); err == nil {
+			c.statusMu.Lock()
+			was := c.status.FaultCode
+			c.status.FaultCode = code
+			c.status.FaultText = FaultName(code)
+			c.statusMu.Unlock()
+			if code != was && code != 0 {
+				applog.Printf("kpa: FAULT %02X — %s", code, FaultName(code))
+			}
+		}
+	}
+
+	if n%slowEvery != 0 {
+		return
+	}
+	// The readings that do not move fast. Each is optional: an older firmware or
+	// a KPA500 that does not know one of these must not take the rest down with
+	// it, so a failure here leaves the previous value standing.
+	if reply, err := c.ask("^OS;"); err == nil {
+		if v, err := parseInt(reply, "^OS"); err == nil {
+			c.statusMu.Lock()
+			c.status.Operate = v == 1
+			c.statusMu.Unlock()
+		}
+	}
+	if reply, err := c.ask("^ON;"); err == nil {
+		if v, err := parseInt(reply, "^ON"); err == nil {
+			c.statusMu.Lock()
+			c.status.PowerOn = v == 1
+			c.statusMu.Unlock()
+		}
+	}
+	if reply, err := c.ask("^VI;"); err == nil {
+		if v, a, err := parseVI(reply); err == nil {
+			c.statusMu.Lock()
+			c.status.VoltV, c.status.CurA = v, a
+			c.statusMu.Unlock()
+		}
+	}
+	if reply, err := c.ask("^TM;"); err == nil {
+		if v, err := parseInt(reply, "^TM"); err == nil {
+			c.statusMu.Lock()
+			c.status.TempC = v
+			c.statusMu.Unlock()
+		}
+	}
+	if reply, err := c.ask("^BN;"); err == nil {
+		if v, err := parseInt(reply, "^BN"); err == nil {
+			c.statusMu.Lock()
+			c.status.Band = BandName(v)
+			c.statusMu.Unlock()
+		}
+	}
+	if reply, err := c.ask("^TP;"); err == nil {
+		if v, err := parseInt(reply, "^TP"); err == nil {
+			c.statusMu.Lock()
+			c.status.Tuning = v == 1
+			c.statusMu.Unlock()
+		}
+	}
+}
+
+// SetBand puts the amplifier on a band by its ADIF name.
+//
+// The KPA takes its band from the transceiver on its own XCVR connector, but it
+// also accepts ^BN — so OpsLog can simply say it on the link it is already
+// using. That is worth knowing: an Acom has no such command, which is why
+// following it needs a second serial port and a transceiver emulator answering
+// its polls (internal/catemu). None of that applies here.
+//
+// Sent only when it CHANGES. Repeating the current band four times a second
+// would be traffic on a link with no flow control, in exchange for nothing.
+func (c *Client) SetBand(adifBand string) error {
+	n, ok := bandNumber(adifBand)
+	if !ok {
+		// Not an error the operator should see: the KPA covers 160-6 m, and
+		// tuning to 23 cm is not a fault, it is simply not this amplifier's
+		// business.
+		return nil
+	}
+	c.statusMu.Lock()
+	same := c.status.Band == adifBand
+	c.statusMu.Unlock()
+	if same {
+		return nil
+	}
+	return c.send(fmt.Sprintf("^BN%02d;", n))
+}
+
+// bandNumber is BandName backwards.
+func bandNumber(adifBand string) (int, bool) {
+	b := strings.ToLower(strings.TrimSpace(adifBand))
+	for n, name := range bandNames {
+		if name == b {
+			return n, true
+		}
+	}
+	return 0, false
+}

internal/kpa/parse.go

@@ -0,0 +1,157 @@
+package kpa
+
+// Decoding the amplifier's answers.
+//
+// Every format here is quoted from the KPA1500 Programming Reference, with the
+// document's own example kept in the test next door. That is the whole
+// discipline: a meter decoded from a guess reports a good match on a bad
+// antenna, and nobody finds out until something is damaged.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// payload strips the leading "^", the command letters and the trailing ";",
+// leaving the value. Returns false when the answer is not for this command —
+// which happens on a shared serial line and on the first read after a
+// reconnect, where a stale reply is still in flight.
+func payload(reply, cmd string) (string, bool) {
+	r := strings.TrimSpace(reply)
+	r = strings.TrimSuffix(r, ";")
+	r = strings.TrimPrefix(r, "^")
+	cmd = strings.TrimSuffix(strings.TrimPrefix(cmd, "^"), ";")
+	if !strings.HasPrefix(strings.ToUpper(r), strings.ToUpper(cmd)) {
+		return "", false
+	}
+	return strings.TrimSpace(r[len(cmd):]), true
+}
+
+// parseWS reads forward power and SWR from one answer.
+//
+//	^WS1204 014;  →  1204 W, SWR 1.4
+//
+// The watts field is FOUR digits on a KPA1500 and THREE on a KPA500 — the
+// reference says so where it explains that ^WS exists for KPA500 compatibility
+// — so the split is on the space and not on a width. The SWR is in tenths, the
+// same units as everywhere else in this protocol.
+func parseWS(reply string) (watts int, swr float64, err error) {
+	v, ok := payload(reply, "^WS")
+	if !ok {
+		return 0, 0, fmt.Errorf("not a ^WS answer: %q", reply)
+	}
+	f := strings.Fields(v)
+	if len(f) != 2 {
+		return 0, 0, fmt.Errorf("^WS wants two fields, got %q", v)
+	}
+	w, err1 := strconv.Atoi(f[0])
+	s, err2 := strconv.Atoi(f[1])
+	if err1 != nil || err2 != nil {
+		return 0, 0, fmt.Errorf("^WS not numeric: %q", v)
+	}
+	return w, float64(s) / 10, nil
+}
+
+// parseVI reads the PA supply voltage and current.
+//
+//	^VI513 061;  →  51.3 V, 61 A
+//
+// Volts in TENTHS, amps whole. Two different scales in one answer, which is
+// exactly the kind of detail that is wrong when it is assumed.
+func parseVI(reply string) (volts float64, amps int, err error) {
+	v, ok := payload(reply, "^VI")
+	if !ok {
+		return 0, 0, fmt.Errorf("not a ^VI answer: %q", reply)
+	}
+	f := strings.Fields(v)
+	if len(f) != 2 {
+		return 0, 0, fmt.Errorf("^VI wants two fields, got %q", v)
+	}
+	dv, err1 := strconv.Atoi(f[0])
+	a, err2 := strconv.Atoi(f[1])
+	if err1 != nil || err2 != nil {
+		return 0, 0, fmt.Errorf("^VI not numeric: %q", v)
+	}
+	return float64(dv) / 10, a, nil
+}
+
+// parseInt reads the plain numeric answers: ^TMxxx (°C), ^PCnnn (A),
+// ^BNbb (band number), ^OSx, ^ONx, ^TPx.
+func parseInt(reply, cmd string) (int, error) {
+	v, ok := payload(reply, cmd)
+	if !ok {
+		return 0, fmt.Errorf("not a %s answer: %q", cmd, reply)
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(v))
+	if err != nil {
+		return 0, fmt.Errorf("%s not numeric: %q", cmd, v)
+	}
+	return n, nil
+}
+
+// parseFault reads ^FLhh — TWO HEX DIGITS, not decimal. Fault 90 is reflected
+// power and fault 91 is "antenna not connected"; read as decimal they would be
+// 144 and 145 and match nothing in the table.
+func parseFault(reply string) (int, error) {
+	v, ok := payload(reply, "^FL")
+	if !ok {
+		return 0, fmt.Errorf("not a ^FL answer: %q", reply)
+	}
+	n, err := strconv.ParseInt(strings.TrimSpace(v), 16, 32)
+	if err != nil {
+		return 0, fmt.Errorf("^FL not hex: %q", v)
+	}
+	return int(n), nil
+}
+
+// faultNames is the table from the reference, keyed by the hex code.
+//
+// Said in the operator's terms rather than the amplifier's: "the antenna is not
+// connected" is a thing to go and fix, "fault 91" is a thing to go and look up.
+var faultNames = map[int]string{
+	0x00: "no fault",
+	0x10: "watchdog timer reset",
+	0x20: "PA current too high",
+	0x40: "too hot — clears as it cools",
+	0x60: "drive power too high",
+	0x61: "gain too low for the drive",
+	0x70: "frequency outside a ham band",
+	0x80: "50 V supply out of range",
+	0x81: "5 V supply out of range",
+	0x82: "10 V supply out of range",
+	0x83: "12 V supply out of range",
+	0x84: "-12 V supply out of range",
+	0x85: "no LPF board supply detected",
+	0x90: "reflected power too high",
+	0x91: "SWR very high — antenna not connected?",
+	0x92: "the ATU found no match",
+	0xB0: "dissipated power too high",
+	0xC0: "forward power too high",
+	0xC1: "forward power too high for this ATU setting",
+	0xF0: "gain too high for the drive",
+}
+
+// FaultName describes a fault code, or says the code itself when the firmware
+// reports one this table does not know — a newer amplifier must not be able to
+// produce a blank explanation.
+func FaultName(code int) string {
+	if code == 0 {
+		return ""
+	}
+	if s, ok := faultNames[code]; ok {
+		return s
+	}
+	return fmt.Sprintf("fault %02X", code)
+}
+
+// bandNames maps ^BN to the ADIF band. The numbering is the K3/K4 one, which is
+// why it is worth writing down: it is not frequency order beyond 6 m and there
+// is no arithmetic that produces it.
+var bandNames = map[int]string{
+	0: "160m", 1: "80m", 2: "60m", 3: "40m", 4: "30m", 5: "20m",
+	6: "17m", 7: "15m", 8: "12m", 9: "10m", 10: "6m",
+}
+
+// BandName is the ADIF band for a ^BN number, or "" when unknown.
+func BandName(n int) string { return bandNames[n] }

internal/kpa/parse_test.go

@@ -0,0 +1,104 @@
+package kpa
+
+import "testing"
+
+// The reference's own examples, kept as the test. Every one of these strings is
+// quoted from the KPA1500 Programming Reference rather than invented here, so a
+// change that breaks the decoding fails against the document.
+func TestParseTheDocumentedExamples(t *testing.T) {
+	t.Run("^WS — forward power and SWR", func(t *testing.T) {
+		w, swr, err := parseWS("^WS1204 014;")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if w != 1204 || swr != 1.4 {
+			t.Errorf("got %d W, SWR %.1f; want 1204 W, SWR 1.4", w, swr)
+		}
+	})
+
+	// A KPA500 sends three digits for the watts. The split is on the space, so
+	// the same code reads both amplifiers.
+	t.Run("^WS from a KPA500 — three digits", func(t *testing.T) {
+		w, swr, err := parseWS("^WS480 021;")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if w != 480 || swr != 2.1 {
+			t.Errorf("got %d W, SWR %.1f; want 480 W, SWR 2.1", w, swr)
+		}
+	})
+
+	t.Run("^VI — volts in tenths, amps whole", func(t *testing.T) {
+		v, a, err := parseVI("^VI513 061;")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if v != 51.3 || a != 61 {
+			t.Errorf("got %.1f V, %d A; want 51.3 V, 61 A", v, a)
+		}
+	})
+
+	t.Run("^TM — heat sink temperature", func(t *testing.T) {
+		c, err := parseInt("^TM045;", "^TM")
+		if err != nil || c != 45 {
+			t.Errorf("got %d, %v; want 45", c, err)
+		}
+	})
+
+	t.Run("^OS — operate or standby", func(t *testing.T) {
+		for reply, want := range map[string]int{"^OS0;": 0, "^OS1;": 1} {
+			got, err := parseInt(reply, "^OS")
+			if err != nil || got != want {
+				t.Errorf("%s → %d, %v; want %d", reply, got, err, want)
+			}
+		}
+	})
+
+	t.Run("^BN — the K3 band numbering", func(t *testing.T) {
+		n, err := parseInt("^BN05;", "^BN")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if got := BandName(n); got != "20m" {
+			t.Errorf("^BN05 → %q, want 20m", got)
+		}
+		if got := BandName(10); got != "6m" {
+			t.Errorf("^BN10 → %q, want 6m", got)
+		}
+	})
+}
+
+// ^FL is HEX. Read as decimal, 90 and 91 — reflected power and "antenna not
+// connected" — become 144 and 145 and match nothing at all, so the amplifier
+// would be shut down by a fault OpsLog could not name.
+func TestFaultCodesAreHex(t *testing.T) {
+	code, err := parseFault("^FL91;")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if code != 0x91 {
+		t.Fatalf("^FL91 → %d, want %d (0x91)", code, 0x91)
+	}
+	if name := FaultName(code); name == "" || name == "fault 91" {
+		t.Errorf("0x91 should be named, got %q", name)
+	}
+	if got := FaultName(0); got != "" {
+		t.Errorf("no fault should be empty, got %q", got)
+	}
+	// A code from a firmware newer than this table still says something.
+	if got := FaultName(0xAB); got != "fault AB" {
+		t.Errorf("unknown code → %q, want \"fault AB\"", got)
+	}
+}
+
+// Answers to somebody else's question are refused rather than misread. On a
+// serial line shared with the amplifier's own utility, or on the first read
+// after a reconnect, a stale reply is still in flight.
+func TestPayloadRefusesAnotherCommandsAnswer(t *testing.T) {
+	if _, _, err := parseWS("^VI513 061;"); err == nil {
+		t.Error("a ^VI answer was accepted as ^WS")
+	}
+	if _, err := parseInt("^TM045;", "^PC"); err == nil {
+		t.Error("a ^TM answer was accepted as ^PC")
+	}
+}

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.18"
 
 	// 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, " | ")
+}