chore: release v0.26.15

The TCI section of the audio settings was an investigation: open the
stream, read what arrives, record ten seconds to listen to, key a tone.
It answered every question it was built for — the frame layout, the
sample width, that the radio asks rather than follows a clock, that the
transmit audio source decides — and confirmed 80 W on real hardware.

None of that belongs in front of an operator now. The radio is simply one
of the devices in the two dropdowns, and choosing it IS the configuration:
one control, in the place where the question is already being asked.
Keeping the tick box beside it would have been two switches for one
decision, with the second one where nobody looks.

Gone with it: the stream/record/probe bindings, the audio.tci_rx setting,
and twenty-four translation keys. The plumbing they proved out stays and
now carries the voice keyer.

antgenius_myant.go

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

antgenius_myant_test.go

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

app.go

@@ -106,6 +106,7 @@ const (
 	keyListsRSTPhone   = "lists.rst_phone"
 	keyListsRSTCW      = "lists.rst_cw"
 	keyListsRSTDigital = "lists.rst_digital"
+	keyListsSatellites = "lists.satellites" // the satellites this station works (SAT_NAME dropdown)
 
 	keyCATEnabled    = "cat.enabled"
 	keyCATBackend    = "cat.backend"     // "omnirig" | "flex"
@@ -132,8 +133,15 @@ const (
 	keyCATYaesuPort       = "cat.yaesu.port"      // Yaesu CAT serial port (e.g. COM4)
 	keyCATYaesuBaud       = "cat.yaesu.baud"      // Yaesu CAT baud (FTDX10/101 default 38400)
 	keyCATKenwoodHost     = "cat.kenwood.host"    // Kenwood CAT over a network serial bridge (ser2net), "host:port"
-	keyCATKenwoodPort     = "cat.kenwood.port"    // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	// keyCATKenwoodLink says HOW the radio is reached: "usb" (a COM port),
-	keyCATKenwoodBaud     = "cat.kenwood.baud"    // Kenwood CAT baud (TS-590 default 9600, TS-890 115200)
+	// "bridge" (the same CAT bytes over TCP — ser2net, an Ethernet-serial
+	// adapter), or "native" (the radio's own network protocol). Kept apart from
+	// the address because the three are different transports, and inferring the
+	// choice from whether a field happened to be filled in is how an operator
+	// ends up with a host typed in and a radio that never answers.
+	keyCATKenwoodLink = "cat.kenwood.link"
+	keyCATKenwoodPort = "cat.kenwood.port" // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	keyCATKenwoodBaud = "cat.kenwood.baud" // Kenwood CAT baud (TS-590 default 9600, TS-890 115200)
 	// One key PER BACKEND, deliberately not shared. A Xiegu fix that reached
 	// into the Yaesu and Kenwood backends is what broke them in 0.22.7/0.22.8;
 	// the rule since is that nothing a backend does may be steered by another
@@ -312,6 +320,7 @@ const (
 	keyClusterSelfSpot    = "cluster.self_spot"         // "1" → announce ourselves on the cluster as we log
 	keyClusterSelfSpotMin = "cluster.self_spot_minutes" // shortest gap between two self-spots
 	keyClusterSpotTTL     = "cluster.spot_ttl_min"      // drop spots older than this; 0 = keep them
+	keyClusterSpotMax     = "cluster.spot_max"          // how many spots the list holds at once
 
 	keyScpEnabled = "scp.enabled" // Super Check Partial / N+1 suggestions on
 
@@ -456,6 +465,9 @@ type CATSettings struct {
 	KenwoodHost     string `json:"kenwood_host"`      // "host:port" of a serial-over-network bridge (ser2net, Ethernet-serial
 	// adapter). NOT the radio’s own RJ45, which speaks Kenwood’s KNS/ARCP.
 	KenwoodPort string `json:"kenwood_port"` // Kenwood CAT serial port (TS-590/890/2000, Elecraft)
+	// KenwoodLink: "usb" | "bridge" | "native". Empty means usb, unless a host
+	// was already configured by an older build — see GetCATSettings.
+	KenwoodLink string `json:"kenwood_link"`
 	KenwoodBaud int    `json:"kenwood_baud"` // Kenwood CAT baud (TS-590 default 9600)
 	// What a DATA/digital mode (FT8, PSK…) sets on the rig: "usb" (default), "data"
 	// (MD6 — Elecraft K3/K4 DATA mode) or "keep" (leave the rig's mode untouched,
@@ -515,6 +527,12 @@ type ListsSettings struct {
 	RSTPhone   []string     `json:"rst_phone"`   // RS reports for phone modes
 	RSTCW      []string     `json:"rst_cw"`      // RST reports for CW/RTTY/PSK
 	RSTDigital []string     `json:"rst_digital"` // dB reports for FT8/FT4/JT…
+	// Satellites the station works, offered as a dropdown on the satellite
+	// fields. A list rather than free text because SAT_NAME is matched
+	// character for character by the awards and by LoTW: "AO-91" and "AO91"
+	// are two different satellites to everything downstream, and typing it
+	// afresh on every pass is how one of them appears in a log.
+	Satellites []string `json:"satellites"`
 }
 
 var defaultBands = []string{
@@ -780,33 +798,40 @@ 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
-	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)
+	// hamlogUnmatched holds the confirmations the last HAMLOG.online import
-	syncMu         sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
+	// could not place onto a QSO, kept so they can be exported and worked
-	syncSent       int64                  // changes written to the folder this session
+	// through — see ExportHamlogUnmatched. Replaced by each import, never
-	syncReceived   int64                  // changes taken from the other machines this session
+	// accumulated: it describes one run, not a history.
-	syncLast       time.Time              // last completed pass, for the status panel
+	hamlogUnmatchedMu sync.Mutex
-	syncErr        string                 // last folder error, shown in settings — a share that dropped is otherwise invisible
+	hamlogUnmatched   []qso.QSO
-	relayAutoMu    sync.Mutex             // serialises relay auto-control evaluation
+	udpLogMu          sync.Mutex             // serialises UDP auto-log so concurrent packets can't both pass the dedup check
-	relayAutoLast  map[string]bool        // deviceID|relay → last applied on/off, so we only switch on a real change
+	adifMonMu         sync.Mutex             // guards the ADIF-monitor config (file list + per-file read offsets)
-	relayAutoOn    atomic.Bool            // cached "auto-control enabled" so the CAT hot path skips work when off
+	syncMu            sync.Mutex             // serialises folder synchronisation: config, the seq counter, and the append to our own file
-	relayDrvMu     sync.Mutex             // guards the cached relay drivers below
+	syncSent          int64                  // changes written to the folder this session
-	relayDrv       map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
+	syncReceived      int64                  // changes taken from the other machines this session
-	pttPort        serial.Port            // open serial port while PTT (RTS/DTR) is asserted
+	syncLast          time.Time              // last completed pass, for the status panel
-	pttKeyedMethod string                 // "cat" | "rts" | "dtr" while keyed; "" when idle
+	syncErr           string                 // last folder error, shown in settings — a share that dropped is otherwise invisible
-	pttGen         int64                  // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
+	relayAutoMu       sync.Mutex             // serialises relay auto-control evaluation
-	startupErr     string                 // captured for surfacing to the frontend
+	relayAutoLast     map[string]bool        // deviceID|relay → last applied on/off, so we only switch on a real change
-	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
+	relayAutoOn       atomic.Bool            // cached "auto-control enabled" so the CAT hot path skips work when off
-	dbPath         string                 // settings/config database file (settings + profiles); may be a user-chosen location
+	relayDrvMu        sync.Mutex             // guards the cached relay drivers below
-	logbookPath    string                 // default SQLite logbook file (QSOs), next to the settings db — used when a profile doesn't point elsewhere
+	relayDrv          map[string]cachedRelay // deviceID → live driver (reused across polls; stateful boards can't be reopened per call)
-	logDbPath      string                 // resolved SQLite file actually backing logDb ("" on MySQL, or when the settings db serves as the logbook) — the file the backup snapshots
+	pttPort           serial.Port            // open serial port while PTT (RTS/DTR) is asserted
-	logDb          *sql.DB                // QSO logbook connection — MySQL, a per-profile SQLite file, or the default logbook.db (never the settings db, except on fallback)
+	pttKeyedMethod    string                 // "cat" | "rts" | "dtr" while keyed; "" when idle
-	dbBackend      string                 // "sqlite" | "mysql" — the logbook backend actually opened at startup
+	pttGen            int64                  // bumped on every key; a delayed unkey only fires if unchanged (guards against a stale release cutting a new transmission)
-	dbBackendErr   string                 // non-empty when a configured MySQL backend failed and we fell back to SQLite
+	startupErr        string                 // captured for surfacing to the frontend
-	offlineQ       *offlineq.Queue        // ADIF outbox: QSOs logged while the DB was unreachable
+	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
-	offlineMode    bool                   // last write failed because the DB was unreachable
+	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
+	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)
+	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
+	offlineQ          *offlineq.Queue        // ADIF outbox: QSOs logged while 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
@@ -969,6 +994,11 @@ func NewApp() *App { return &App{} }
 
 func (a *App) startup(ctx context.Context) {
 	a.ctx = ctx
+	// One line in the startup log too, not only in OpsLog's own: the two
+	// together say whether a launch that produced no window got as far as our
+	// code at all, which is the fork every "it does not start" report turns on.
+	startupReached.Store(true)
+	bootLog("OnStartup reached")
 
 	dataDir, err := userDataDir()
 	if err != nil {
@@ -1529,6 +1559,8 @@ func (a *App) startup(ctx context.Context) {
 // it — it appears already sized and positioned, never jumping into place after
 // launch. Show is unconditional: whatever happens above, the window must appear.
 func (a *App) domReady(ctx context.Context) {
+	bootLog("OnDomReady reached — the window has painted")
+	clearLaunchMarker()
 	a.restoreWindowPosition()
 	wruntime.WindowShow(ctx)
 	// The one number that matches what the operator actually experiences: click
@@ -2093,6 +2125,7 @@ func (a *App) restoreWindowPosition() {
 	if a.ctx == nil {
 		return
 	}
+	logMonitorLayout()
 	ws, ok := readWindowState(a.dataDir)
 	if !ok {
 		applog.Printf("window: no saved geometry — opening where Windows puts it")
@@ -2131,8 +2164,19 @@ func (a *App) restoreWindowPosition() {
 	// forever — with no way back short of deleting window.json, which nobody
 	// knows to do. Fall back to the default placement instead.
 	if !onSomeMonitor(ws.X, ws.Y, ws.Width, ws.Height) {
-		applog.Printf("window: saved position %d,%d (%dx%d) is off every monitor — opening at the default placement",
+		// Moved onto the nearest monitor rather than handed back to Windows.
-			ws.X, ws.Y, ws.Width, ws.Height)
+		// Giving up lost the size as well as the position and dropped the window
+		// on the primary screen wherever Windows felt like; clamping keeps the
+		// window the operator had, somewhere they can see it.
+		nx, ny, moved := clampToVisible(ws.X, ws.Y, ws.Width, ws.Height)
+		if !moved {
+			applog.Printf("window: saved position %d,%d (%dx%d) is off every monitor and no monitor could be read — opening at the default placement",
+				ws.X, ws.Y, ws.Width, ws.Height)
+			return
+		}
+		applog.Printf("window: saved position %d,%d is off every monitor (%s) — moved to %d,%d",
+			ws.X, ws.Y, describeMonitors(monitorRects()), nx, ny)
+		wruntime.WindowSetPosition(a.ctx, nx, ny)
 		return
 	}
 	wruntime.WindowSetPosition(a.ctx, ws.X, ws.Y)
@@ -2143,13 +2187,7 @@ func (a *App) restoreWindowPosition() {
 // pixel: a window overlapping the screen edge by 2 px is, in practice, as lost
 // as one entirely outside it. When the desktop bounds can't be read, it says yes
 // — better to honour the operator's saved position than to second-guess it.
-func onSomeMonitor(x, y, w, h int) bool {
+func onSomeMonitor(x, y, w, h int) bool { return onSomeMonitorImpl(x, y, w, h) }
-	vx, vy, vw, vh, ok := virtualScreenBounds()
-	if !ok {
-		return true
-	}
-	return overlapsEnough(x, y, w, h, vx, vy, vw, vh)
-}
 
 // overlapsEnough is the geometry behind onSomeMonitor, split out so it can be
 // tested — the virtual desktop origin is NEGATIVE when a monitor sits left of or
@@ -3316,6 +3354,9 @@ func (a *App) applyStationDefaults(q *qso.QSO, includeIdentity bool) {
 	if q.MyAntenna == "" {
 		q.MyAntenna = p.MyAntenna
 	}
+	// The switch has the last word, when asked to: everything above is what was
+	// PLANNED for this band, and the Antenna Genius knows what is connected.
+	a.applyAntGeniusAntenna(&q.MyAntenna)
 	if q.TXPower == nil && p.TxPower != nil {
 		v := *p.TxPower
 		q.TXPower = &v
@@ -6503,6 +6544,21 @@ func (a *App) deleteRemoteCopies(ids []int64) {
 // withdrawals stop. Three is enough to tell a one-off from a blocked account.
 const maxClublogRefusals = 3
 
+// Club Log's delete endpoint is a REAL-TIME one: it exists for an operator
+// removing a contact they just logged wrongly, at human pace. Club Log watches
+// the rate and blocks the IP of anything that batches through it — they wrote
+// to this station about 167 requests in four minutes, which was one deletion of
+// a couple of hundred rows, not a pile-up.
+//
+// There is no bulk-delete API to move to, so the only honest answer is to go at
+// the pace the endpoint is meant for and to stop rather than push a large
+// deletion through it. Whoever needs to remove hundreds of QSOs from Club Log
+// does it on their site, where the tool for it exists.
+const (
+	clublogDeletePace = 1200 * time.Millisecond
+	maxClublogDeletes = 25
+)
+
 // clublogWasUploaded reports whether this QSO ever reached Club Log. "M"
 // (modified since upload) counts: the copy is there, it is merely out of date.
 func clublogWasUploaded(status string) bool {
@@ -6516,6 +6572,7 @@ func clublogWasUploaded(status string) bool {
 func (a *App) withdrawRemoteCopies(rows []qso.QSO, cfg extsvc.ExternalServices, doQRZ, doClublog bool) {
 	started := time.Now()
 	clublogRefused := 0
+	clublogSent := 0
 	for i := range rows {
 		q := rows[i]
 		id := q.ID
@@ -6546,6 +6603,17 @@ func (a *App) withdrawRemoteCopies(rows []qso.QSO, cfg extsvc.ExternalServices,
 		if doClublog && !clublogWasUploaded(q.ClublogUploadStatus) {
 			applog.Printf("extsvc: QSO %d (%s) was never uploaded to Club Log — nothing to withdraw", id, q.Callsign)
 		} else if doClublog {
+			if clublogSent >= maxClublogDeletes {
+				applog.Printf("extsvc: %d QSOs already withdrawn from Club Log — stopping there. Their delete endpoint is for one contact at a time; remove the rest on clublog.org, which has a tool for it.", clublogSent)
+				doClublog = false
+				continue
+			}
+			if clublogSent > 0 {
+				// Paced deliberately: see clublogDeletePace. This runs in the
+				// background, so the wait costs the operator nothing.
+				time.Sleep(clublogDeletePace)
+			}
+			clublogSent++
 			if msg, err := extsvc.DeleteClublog(a.ctx, nil, cfg.Clublog, q.Callsign, q.QSODate, q.Band); err != nil {
 				clublogRefused++
 				applog.Printf("extsvc: Club Log delete of QSO %d (%s) failed: %v", id, q.Callsign, err)
@@ -8000,27 +8068,30 @@ func (a *App) GetCATSettings() (CATSettings, error) {
 	if a.settings == nil {
 		return CATSettings{Backend: "omnirig", OmniRigNum: 1, PollMs: 250}, fmt.Errorf("db not initialized")
 	}
-	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort)
+	m, err := a.settings.GetMany(a.ctx, keyCATEnabled, keyCATBackend, keyCATOmniRigNum, keyCATOmniRigVFO, keyCATFlexHost, keyCATFlexPort, keyCATFlexSpots, keyCATFlexDVKDax, keyCATFlexDecodeSpots, keyCATFlexDecodeSecs, keyCATXieguPort, keyCATXieguBaud, keyCATXieguAddr, keyCATXieguPTTLine, keyCATYaesuPort, keyCATYaesuBaud, keyCATKenwoodPort, keyCATKenwoodBaud, keyCATKenwoodHost, keyCATKenwoodLink, keyCATYaesuLowLines, keyCATKenwoodLowLines, keyCATKenwoodDataMode, keyCATIcomPort, keyCATIcomBaud, keyCATIcomAddr, keyCATIcomNetHost, keyCATIcomNetUser, keyCATIcomNetPass, keyCATIcomNetAudio, keyCATTCIHost, keyCATTCIPort, keyCATTCISpots, keyCATPttHotkeyEnabled, keyCATPttHotkey, keyCATPttHotkeyToggle, keyCATPollMs, keyCATDelayMs, keyCATOffsetOn, keyCATOffsetHz, keyCATDigitalDefault, keyCATShareEnabled, keyCATSharePort, keyCATShareProto, keyCATShareTCIPort)
 	if err != nil {
 		return CATSettings{}, err
 	}
 	out := CATSettings{
-		Enabled:          m[keyCATEnabled] == "1",
+		Enabled:         m[keyCATEnabled] == "1",
-		Backend:          m[keyCATBackend],
+		Backend:         m[keyCATBackend],
-		OmniRigNum:       1,
+		OmniRigNum:      1,
-		FlexHost:         m[keyCATFlexHost],
+		FlexHost:        m[keyCATFlexHost],
-		FlexPort:         4992,
+		FlexPort:        4992,
-		FlexSpots:        m[keyCATFlexSpots] == "1",
+		FlexSpots:       m[keyCATFlexSpots] == "1",
-		FlexDVKDax:       m[keyCATFlexDVKDax] == "1",
+		FlexDVKDax:      m[keyCATFlexDVKDax] == "1",
-		FlexDecodeSpots:  m[keyCATFlexDecodeSpots] == "1",
+		FlexDecodeSpots: m[keyCATFlexDecodeSpots] == "1",
-		FlexDecodeSecs:   120,
+		FlexDecodeSecs:  120,
-		XieguPort:        m[keyCATXieguPort],
+		XieguPort:       m[keyCATXieguPort],
-		XieguBaud:        19200,
+		XieguBaud:       19200,
-		XieguAddr:        cat.XieguDefaultAddr,
+		XieguAddr:       cat.XieguDefaultAddr,
-		YaesuPort:        m[keyCATYaesuPort],
+		YaesuPort:       m[keyCATYaesuPort],
-		YaesuBaud:        38400,
+		YaesuBaud:       38400,
-		KenwoodPort:      m[keyCATKenwoodPort],
+		KenwoodPort:     m[keyCATKenwoodPort],
-		KenwoodHost:      m[keyCATKenwoodHost],
+		KenwoodHost:     m[keyCATKenwoodHost],
+		// An install that predates the setting is read from what it has: a host
+		// filled in meant the bridge, since that is what the old code preferred.
+		KenwoodLink:      kenwoodLinkOr(m[keyCATKenwoodLink], m[keyCATKenwoodHost]),
 		KenwoodBaud:      9600,
 		YaesuLowLines:    m[keyCATYaesuLowLines] == "1",
 		KenwoodLowLines:  m[keyCATKenwoodLowLines] == "1",
@@ -8220,6 +8291,7 @@ func (a *App) SaveCATSettings(s CATSettings) error {
 		keyCATYaesuBaud:        strconv.Itoa(s.YaesuBaud),
 		keyCATKenwoodPort:      strings.TrimSpace(s.KenwoodPort),
 		keyCATKenwoodHost:      strings.TrimSpace(s.KenwoodHost),
+		keyCATKenwoodLink:      kenwoodLinkOr(s.KenwoodLink, s.KenwoodHost),
 		keyCATKenwoodBaud:      strconv.Itoa(s.KenwoodBaud),
 		keyCATYaesuLowLines:    b01(s.YaesuLowLines),
 		keyCATKenwoodLowLines:  b01(s.KenwoodLowLines),
@@ -8278,8 +8350,49 @@ type AudioSettings struct {
 
 // ListAudioInputDevices / ListAudioOutputDevices enumerate WASAPI endpoints
 // for the device dropdowns.
-func (a *App) ListAudioInputDevices() ([]audio.Device, error)  { return audio.ListInputDevices() }
+// ListAudioInputDevices lists the microphones and line inputs, plus THE RADIO
-func (a *App) ListAudioOutputDevices() ([]audio.Device, error) { return audio.ListOutputDevices() }
+// when the CAT link carries its receive audio.
+//
+// Same reasoning as the output list: over TCI there is no sound device for
+// Windows to show, so without this the one correct answer to "where does the
+// received audio come from" could not be chosen at all.
+func (a *App) ListAudioInputDevices() ([]audio.Device, error) {
+	devs, err := audio.ListInputDevices()
+	if err != nil {
+		return devs, err
+	}
+	if a.tciAudioAvailable() {
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+	}
+	return devs, nil
+}
+
+// tciAudioAvailable says whether the active CAT backend is a radio that streams
+// its audio over the CAT link.
+func (a *App) tciAudioAvailable() bool {
+	if a.cat == nil {
+		return false
+	}
+	_, ok := a.cat.TCIAudioState()
+	return ok
+}
+
+// ListAudioOutputDevices lists the sound cards, plus THE RADIO ITSELF when the
+// CAT link can carry transmit audio.
+//
+// Offered only while it is actually available, and named as a radio rather than
+// as a protocol: an operator choosing where their voice goes is picking between
+// "my sound card" and "the radio", not between WASAPI and TCI.
+func (a *App) ListAudioOutputDevices() ([]audio.Device, error) {
+	devs, err := audio.ListOutputDevices()
+	if err != nil {
+		return devs, err
+	}
+	if audio.NetworkPlayerReady() {
+		devs = append([]audio.Device{{ID: audio.NetworkDeviceID, Name: "Radio (TCI network audio)"}}, devs...)
+	}
+	return devs, nil
+}
 
 // GetAudioSettings returns the stored audio config (preroll defaults to 8s).
 func (a *App) GetAudioSettings() (AudioSettings, error) {
@@ -8381,6 +8494,15 @@ 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.
+	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
@@ -8425,7 +8547,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
 	}
@@ -15106,6 +15228,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
@@ -15133,6 +15261,9 @@ func (a *App) reloadCAT() {
 			// looking at the same signal, and only the click's origin differs.
 			a.FlexZoomForSpot(mode, hz)
 		}
+		// Spots posted by ANOTHER program — a CW skimmer, in practice. See
+		// flexrstchase.go: a marked report is where the DX was just listening.
+		fb.OnForeignSpot = a.handleForeignSpot
 		a.cat.Start(fb)
 	case "xiegu":
 		// Xiegu G90/X6100/X6200/X5105 — CI-V, but a REDUCED command set: no scope,
@@ -15152,37 +15283,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":
@@ -15224,7 +15356,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) {
@@ -15343,6 +15482,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...)
 	}
@@ -15358,6 +15500,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
 }
 
@@ -15397,6 +15543,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
 }
 
@@ -17609,6 +17763,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.
@@ -17617,13 +17777,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
 }
 
@@ -17633,9 +17799,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
@@ -20257,6 +20425,48 @@ func (a *App) SetKenwoodKeySpeed(wpm int) error {
 // and exists only so a mistyped value cannot mean "never".
 const spotTTLMax = 720
 
+// The spot list is a ring buffer, and its size decided the lifetime far more
+// often than the lifetime setting did: on a busy evening a thousand spots
+// arrive in a couple of minutes, so a fifteen-minute lifetime never got the
+// chance to expire anything. Hence a setting.
+//
+// The ceiling is a real limit, not a round number. Every spot is matched against
+// the worked index and the alert rules, and each one is a row the cluster grid
+// and every open band map re-render; past ten thousand that work starts to show
+// on the very evenings the list is worth having.
+const (
+	spotMaxDefault = 1000
+	spotMaxCeiling = 10000
+	spotMaxFloor   = 100
+)
+
+// GetSpotMax returns how many spots the list holds.
+func (a *App) GetSpotMax() int {
+	n, _ := strconv.Atoi(a.settingOr(keyClusterSpotMax, ""))
+	if n <= 0 {
+		return spotMaxDefault
+	}
+	return clampSpotMax(n)
+}
+
+// SetSpotMax sets it. Clamped here as well as in the UI, for the same reason as
+// the lifetime: the value decides how much work arrives on every spot, and a
+// stale frontend must not be able to widen it past the ceiling.
+func (a *App) SetSpotMax(n int) error {
+	a.setSetting(keyClusterSpotMax, strconv.Itoa(clampSpotMax(n)))
+	return nil
+}
+
+func clampSpotMax(n int) int {
+	if n < spotMaxFloor {
+		return spotMaxFloor
+	}
+	if n > spotMaxCeiling {
+		return spotMaxCeiling
+	}
+	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

@@ -0,0 +1,120 @@
+package main
+
+// Elecraft K3/K4 panel bindings.
+//
+// The controls the operator asked for and nothing else: power, volume, the
+// S-meter and SWR, MOX, and an ATU tune. A K3 exposes dozens of commands, but a
+// panel earns its place by covering what is reached for during a QSO — and each
+// one added without a radio to test it against is a control that may or may not
+// do what its label says. See internal/cat/kenwood_panel.go.
+
+import (
+	"fmt"
+
+	"hamlog/internal/cat"
+)
+
+// GetKenwoodState returns the K3/K4 panel snapshot. Zero value when the active
+// CAT backend is something else, which is how the UI knows to hide the panel.
+func (a *App) GetKenwoodState() cat.KenwoodTXState {
+	if a.cat == nil {
+		return cat.KenwoodTXState{}
+	}
+	st, _ := a.cat.KenwoodState()
+	return st
+}
+
+func (a *App) SetKenwoodPower(w int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPower(w) })
+}
+
+func (a *App) SetKenwoodAFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAFGain(p) })
+}
+
+func (a *App) SetKenwoodRFGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRFGain(p) })
+}
+
+func (a *App) SetKenwoodMicGain(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodMicGain(p) })
+}
+
+func (a *App) SetKenwoodSquelch(p int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodSquelch(p) })
+}
+
+func (a *App) SetKenwoodPreamp(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodPreamp(on) })
+}
+
+func (a *App) SetKenwoodAtt(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAtt(on) })
+}
+
+func (a *App) SetKenwoodNB(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNB(on) })
+}
+
+func (a *App) SetKenwoodNR(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodNR(on) })
+}
+
+func (a *App) SetKenwoodAGC(name string) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAGC(name) })
+}
+
+func (a *App) SetKenwoodFilter(hz int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodFilter(hz) })
+}
+
+func (a *App) SetKenwoodAntenna(n int) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodAntenna(n) })
+}
+
+func (a *App) SetKenwoodRIT(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodRIT(on) })
+}
+
+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 {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ClearKenwoodRIT() })
+}
+
+// SetKenwoodTX is the panel's MOX.
+func (a *App) SetKenwoodTX(on bool) error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.SetKenwoodTX(on) })
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it (the HOLD of the same
+// front-panel switch the tune uses).
+func (a *App) ToggleKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.ToggleKenwoodATU() })
+}
+
+func (a *App) TuneKenwoodATU() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.TuneKenwoodATU() })
+}
+
+// RefreshKenwood re-reads the settings on the next poll — for when a knob was
+// turned on the radio itself.
+func (a *App) RefreshKenwood() error {
+	return a.kenwoodPanelDo(func(k cat.KenwoodPanelController) error { return k.RefreshKenwood() })
+}
+
+func (a *App) kenwoodPanelDo(fn func(cat.KenwoodPanelController) error) error {
+	if a.cat == nil {
+		return fmt.Errorf("CAT not initialized")
+	}
+	return a.cat.KenwoodPanelDo(fn)
+}

app_tci_dvk.go

@@ -0,0 +1,60 @@
+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)
+}
+
+// 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)
+	applog.Printf("tci: the radio is available as an audio output — no virtual cable needed for the voice keyer")
+}

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

changelog.json

@@ -1,4 +1,132 @@
 [
+  {
+    "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": "",
+    "en": [
+      "When TQSL refuses an upload, the log now carries the exact ADIF record it was given and the station location it was told to sign with. 'No QSOs processed' covers several unrelated causes and the temp file is deleted the moment TQSL returns, so the one piece of evidence that mattered was the one nobody could see.",
+      "An Elecraft console for the K3/K4, in a tab of its own when the CAT backend is Elecraft or Kenwood: power, volume, RF and mic gain, squelch, preamp, attenuator, NB, NR, AGC, filter width, antenna, RIT/XIT with a clear, keyer speed, S-meter, SWR, MOX and an ATU tune. The meter scaling is marked provisional and the raw readings go to the log — it was written from the K3 Programmer's Reference without a radio to hand, and a wrongly scaled SWR bar reports a good match on a bad antenna.",
+      "Type a number in the callsign field and press Enter to move the radio: kHz for a frequency (28500 → 28.500 MHz), or a band on its own (20, 160, 6…). It is where the hands already are — reading a spot and reaching for the frequency box is what loses the station. Ambiguous numbers are read as bands, since 40 kHz and 160 kHz are nowhere anyone tunes.",
+      "Yaesu console: the mic gain is read and written on the rig's own 0-100 scale. It was treated as 0-255, so an FTDX101 set to 80 showed 38 and every attempt to move the slider was refused by the radio and sprang back.",
+      "Yaesu console: the power slider goes to 200 W on the models that make it (FTDX101MP and the like), and follows the radio if it ever reports more than expected. The slider, not the rig, was the 100 W limit.",
+      "Yaesu console: the NAR button (narrow IF filter) is shown only when the radio answers the command, and says what it is. A button that did nothing when pressed read as a fault in the rig.",
+      "The frequency readout now steps the Hz digits under the mouse wheel too, not just the kHz ones — 100, 10 and 1 Hz. Zero-beating a CW signal is a few tens of Hz, and it was the one move the display would not make.",
+      "The split-pile-up chaser only appears in CW: the marker comes from a skimmer decoding a report, so on SSB or FT8 there is nothing for it to chase.",
+      "Cluster: a single click now only fills the callsign, and a DOUBLE click works the spot — QSY, mode and the rest. Running down the list used to drag the radio along with every line looked at.",
+      "Cluster: how many spots the list keeps is now a setting (Preferences → Cluster, beside the spot lifetime). It was fixed at a thousand, and on a busy evening that fills in a couple of minutes — so the cap, not the lifetime, decided when a spot disappeared and a 15-minute lifetime never expired anything.",
+      "Elecraft console: the ATU tune sends the right switch. SWT19 is the ATU row in the K3 reference — TAP starts a tuning cycle, and a HOLD (the new ATU button) puts the tuner in line or bypasses it. It was written as SWT20, which is not an ATU switch at all. Power now takes the K3 range of 0-110 W.",
+      "Elecraft console: the mouse wheel moves the sliders, as it already did on the Flex and Yaesu consoles. Power steps 5 W a notch, the rest one unit."
+    ],
+    "fr": [
+      "Quand TQSL refuse un envoi, le journal contient désormais l'enregistrement ADIF exact qui lui a été remis et l'emplacement de station demandé pour la signature. « No QSOs processed » recouvre plusieurs causes sans rapport et le fichier temporaire est supprimé dès que TQSL rend la main : la seule pièce à conviction utile était justement invisible.",
+      "Une console Elecraft pour les K3/K4, dans un onglet dédié quand le CAT est réglé sur Elecraft ou Kenwood : puissance, volume, gain HF et micro, squelch, préampli, atténuateur, NB, NR, AGC, largeur de filtre, antenne, RIT/XIT avec effacement, vitesse du manipulateur, S-mètre, ROS, MOX et accord de l'ATU. L'échelle des mesures est signalée comme provisoire et les valeurs brutes partent dans le journal — la console a été écrite d'après le manuel de programmation du K3, sans radio sous la main, et une barre de ROS mal calibrée annonce un bon accord sur une mauvaise antenne.",
+      "Taper un nombre dans le champ indicatif puis Entrée déplace la radio : en kHz pour une fréquence (28500 → 28.500 MHz), ou une bande seule (20, 160, 6…). C'est là que sont déjà les mains — lire un spot puis aller chercher la case fréquence, c'est ce qui fait perdre la station. Les nombres ambigus sont lus comme des bandes : 40 kHz ou 160 kHz ne sont nulle part où l'on s'accorde.",
+      "Console Yaesu : le gain micro est lu et écrit sur l'échelle 0-100 de la radio. Il était traité en 0-255 : un FTDX101 réglé sur 80 affichait 38, et toute tentative de bouger le curseur était refusée par la radio et revenait en place.",
+      "Console Yaesu : le curseur de puissance monte à 200 W sur les modèles qui la sortent (FTDX101MP et consorts), et suit la radio si elle annonce davantage. C'était le curseur, pas la radio, qui plafonnait à 100 W.",
+      "Console Yaesu : le bouton NAR (filtre FI étroit) n'apparaît que si la radio répond à la commande, et indique ce qu'il fait. Un bouton sans effet passait pour une panne de la radio.",
+      "L'affichage de fréquence fait maintenant défiler aussi les chiffres des Hz à la molette, pas seulement ceux des kHz — 100, 10 et 1 Hz. Se caler au zéro-beat sur un signal CW se joue à quelques dizaines de Hz, et c'était le seul geste que l'affichage refusait.",
+      "Le chasseur de pile-up en split n'apparaît qu'en CW : le marqueur vient d'un skimmer qui décode un report, donc en SSB ou en FT8 il n'a rien à chasser.",
+      "Cluster : un clic simple ne remplit plus que l'indicatif, et le DOUBLE clic travaille le spot — QSY, mode et le reste. Parcourir la liste entraînait la radio à chaque ligne regardée.",
+      "Cluster : le nombre de spots conservés devient un réglage (Préférences → Cluster, à côté de la durée de vie). Il était fixé à mille, et un soir chargé remplit ça en quelques minutes — c'était donc le plafond, et non la durée de vie, qui décidait de la disparition d'un spot, et une durée de 15 minutes n'expirait jamais rien.",
+      "Console Elecraft : l'accord ATU envoie la bonne touche. SWT19 est la ligne ATU du manuel K3 — l'appui bref lance un cycle d'accord, et le maintien (nouveau bouton ATU) met la boîte en ligne ou la contourne. C'était écrit SWT20, qui n'est pas une touche d'ATU. La puissance suit la plage 0-110 W du K3.",
+      "Console Elecraft : la molette agit sur les curseurs, comme elle le faisait déjà sur les consoles Flex et Yaesu. La puissance avance de 5 W par cran, le reste d'une unité."
+    ]
+  },
+  {
+    "version": "0.26.11",
+    "date": "",
+    "en": [
+      "Withdrawing deleted QSOs from Club Log is now paced and capped at 25 per deletion. Their delete endpoint is a real-time one, meant for an operator removing a contact they just mis-logged; Club Log watches the rate and blocks the IP of anything that batches through it. Past the cap OpsLog stops and says so — there is no bulk-delete API, and hundreds of removals belong on clublog.org, which has a tool for it.",
+      "Auto-call, withdrawn earlier, is now disarmed where it was remembered: a stored 'enabled' is switched off and written back the first time OpsLog reads it. The running guard already stopped this build from calling anyone, but the stored flag survived — and any build without that guard would key the transmitter for a feature with no switch left to turn it off."
+    ],
+    "fr": [
+      "Le retrait des QSO supprimés chez Club Log est désormais cadencé et limité à 25 par suppression. Leur point d'entrée de suppression est temps réel, prévu pour un opérateur qui retire un contact qu'il vient de mal enregistrer ; Club Log surveille le rythme et bloque l'IP de ce qui passe des lots par là. Au-delà de la limite, OpsLog s'arrête et le dit — il n'existe pas d'API de suppression en masse, et des centaines de retraits se font sur clublog.org, qui a l'outil pour ça.",
+      "L'appel automatique, retiré précédemment, est maintenant désarmé là où il était mémorisé : un « activé » enregistré est éteint et réécrit dès la première lecture par OpsLog. Le garde-fou à l'exécution empêchait déjà cette version d'appeler qui que ce soit, mais l'indicateur enregistré survivait — et toute version sans ce garde-fou passait à l'émission pour une fonction dont il ne reste aucun interrupteur."
+    ]
+  },
+  {
+    "version": "0.26.10",
+    "date": "",
+    "en": [
+      "The HAMLOG.online confirmation import now fills the Results view with the contacts it confirmed, flagged new entity / band / mode / slot, and can export the unmatched ones as ADIF. Those are the interesting half: each is a contact their site holds and the log does not confirm — a minute of drift, a portable call, or a QSO genuinely missing.",
+      "Awards: 'county' joins the searchable QSO fields — the CNTY field as it stands. The existing 'us_county' keys the county to its state, which is right for the United States and wrong everywhere else: an RDA district or a Japanese city code is already unique.",
+      "*** FlexRadio: a split pile-up chaser. When a CW skimmer (SDC) marks a report on the panadapter, OpsLog moves the TRANSMIT slice there — where the DX was listening a second ago — plus a signed offset in Hz; the receive slice never moves. The button sits on the FlexRadio panel beside SPLIT, with the offset next to it. Right-click the button to set the marker text — it has to match what SDC is set to write (599 by default, several allowed), so it is edited where it is switched on rather than in a settings page.***",
+      "The radio's spot feed is now subscribed to even when OpsLog draws no spots of its own — that feed is how another program's spots arrive. Clearing the panadapter at connect still only happens when the overlay is OpsLog's: 'spot clear' removes every spot on the radio, a skimmer's included.",
+      "CW keyer: fixed Enter sending nothing on the Icom, Yaesu and Kenwood engines. Send-on-type only exists on the WinKeyer and Flex CWX, but the setting survived a change of engine — so the switch stayed on, invisibly, and the text field believed everything had already been keyed. Macros were unaffected, which is what made it puzzling."
+    ],
+    "fr": [
+      "L'import des confirmations HAMLOG.online alimente maintenant la vue Résultats avec les contacts confirmés, marqués nouvelle entité / bande / mode / slot, et peut exporter les non-rapprochés en ADIF. C'est la moitié intéressante : chacun est un contact que leur site détient et que le journal ne confirme pas — minute décalée, indicatif portable, ou QSO réellement absent.",
+      "Diplômes : « county » rejoint les champs de QSO interrogeables — le champ CNTY tel quel. Le « us_county » existant associe le comté à son État, ce qui est juste aux États-Unis et faux ailleurs : un district RDA ou un code de ville japonais est déjà unique.",
+      "*** FlexRadio : chasseur de pile-up en split. Quand un skimmer CW (SDC) marque un report sur le panadapter, OpsLog déplace la slice d'ÉMISSION dessus — là où le DX écoutait une seconde plus tôt — plus un décalage signé en Hz ; la slice de réception ne bouge jamais. Le bouton est sur le panneau FlexRadio à côté de SPLIT, avec le décalage juste à côté. Clic droit sur le bouton pour régler le texte du marqueur — il doit correspondre à ce que SDC est réglé à écrire (599 par défaut, plusieurs possibles), donc il se modifie là où on l'active plutôt que dans les réglages.***",
+      "Le flux de spots de la radio est désormais suivi même si OpsLog n'affiche aucun spot : c'est par lui qu'arrivent les spots des autres programmes. Le nettoyage du panadapter à la connexion reste réservé au cas où l'affichage est celui d'OpsLog : « spot clear » efface tous les spots de la radio, y compris ceux d'un skimmer.",
+      "Manipulateur CW : correction d'Entrée qui n'envoyait rien sur les moteurs Icom, Yaesu et Kenwood. L'émission au fil de la frappe n'existe que sur le WinKeyer et le Flex CWX, mais le réglage survivait à un changement de moteur — l'interrupteur restait donc actif, invisible, et le champ de texte croyait que tout avait déjà été émis. Les macros n'étaient pas touchées, ce qui rendait la chose incompréhensible."
+    ]
+  },
   {
     "version": "0.26.9",
     "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)
+}

flexrstchase.go

@@ -0,0 +1,187 @@
+package main
+
+// Chasing a split pile-up by the report the DX just sent.
+//
+// Working a DXpedition in split means guessing where it is listening. The DX
+// answers one station, sends "5NN", and moves on; the useful information is
+// therefore not the callsign it answered but the FREQUENCY that callsign was
+// transmitting on, because the DX's receiver was there a second ago.
+//
+// A CW skimmer already knows this. SDC (Software Defined Connector) decodes the
+// whole pile-up and marks each report on the panadapter as a spot — the marker
+// TEXT is configured in SDC by the operator ("599" for a fresh report, "X" for
+// an older one, by default). Those spots reach OpsLog already: it subscribes to
+// the radio's spot feed, and every spot another program posts arrives on
+// Flex.OnForeignSpot.
+//
+// So the whole feature is: recognise the marker, move the TRANSMIT slice there,
+// leave the receive slice on the DX. Nothing here decodes anything.
+//
+// Three deliberate choices:
+//
+//   - the marker text is a SETTING, not a constant. It is chosen in SDC, and
+//     any guess made here would be wrong for the operator who chose otherwise.
+//   - only the transmit slice moves, never the receive slice. Losing the DX is
+//     a worse outcome than a missed call.
+//   - the offset is signed and in Hz, because working "up a bit" from where the
+//     last station was answered is exactly how a pile-up is chased.
+
+import (
+	"encoding/json"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"hamlog/internal/applog"
+	"hamlog/internal/cat"
+)
+
+const keyFlexRSTChase = "flex.rst_chase"
+
+// FlexRSTChase is the whole configuration.
+type FlexRSTChase struct {
+	Enabled bool `json:"enabled"`
+	// Markers are the skimmer's marker texts, comma-separated ("599,5NN").
+	// Matched against the spot's callsign field, case-insensitively and whole:
+	// a spot IS the marker or it is an ordinary callsign, and a substring rule
+	// would drag in any station whose call happens to contain the digits.
+	Markers string `json:"markers"`
+	// OffsetHz is added to the marker's frequency. Signed: chasing upward from
+	// the last station worked is the usual tactic, downward happens too.
+	OffsetHz int `json:"offset_hz"`
+	// SplitOnly refuses to act when the radio is not in split. On by default:
+	// out of split the transmit slice IS the receive slice, so "move the TX
+	// slice" would take the operator off the DX they are listening to.
+	SplitOnly bool `json:"split_only"`
+}
+
+var defaultFlexRSTChase = FlexRSTChase{Enabled: false, Markers: "599", OffsetHz: 0, SplitOnly: true}
+
+// rstChaseMinGap throttles the moves. A skimmer marks every report it decodes,
+// and a busy pile-up produces several a second; without a floor the transmit
+// slice would twitch continuously and never be anywhere long enough to call.
+const rstChaseMinGap = 700 * time.Millisecond
+
+// rstChaseMinStep ignores a marker that lands where the slice already is.
+// Re-sending the same frequency is not free: it is a command to the radio and a
+// slice status back, several times a second, for no change at all.
+const rstChaseMinStep = 20 // Hz
+
+var (
+	rstChaseMu   sync.Mutex
+	rstChaseLast time.Time
+	rstChaseFreq int64
+)
+
+// GetFlexRSTChase returns the stored configuration (defaults when unset).
+func (a *App) GetFlexRSTChase() FlexRSTChase {
+	s := defaultFlexRSTChase
+	if a.settings == nil {
+		return s
+	}
+	// settingOr, NOT settings.Get with profileScope(): the store already applies
+	// the active profile's prefix, so scoping the key here wrote p3.flex.rst_chase
+	// and read p3.p3.flex.rst_chase — the switch could never be read back on, and
+	// the feature did nothing at all with no sign of why.
+	if v := a.settingOr(keyFlexRSTChase, ""); strings.TrimSpace(v) != "" {
+		_ = json.Unmarshal([]byte(v), &s)
+	}
+	return normRSTChase(s)
+}
+
+// SaveFlexRSTChase stores the configuration.
+func (a *App) SaveFlexRSTChase(s FlexRSTChase) error {
+	b, err := json.Marshal(normRSTChase(s))
+	if err != nil {
+		return err
+	}
+	a.setSetting(keyFlexRSTChase, string(b))
+	return nil
+}
+
+// SetFlexRSTChaseEnabled flips the switch alone.
+//
+// Its own binding because this belongs on a button in the panel, not in a
+// settings page: it is turned on when a DXpedition appears and off when it is
+// worked, which is a thing done mid-QSO with one hand.
+func (a *App) SetFlexRSTChaseEnabled(on bool) error {
+	s := a.GetFlexRSTChase()
+	s.Enabled = on
+	return a.SaveFlexRSTChase(s)
+}
+
+func normRSTChase(s FlexRSTChase) FlexRSTChase {
+	if strings.TrimSpace(s.Markers) == "" {
+		s.Markers = defaultFlexRSTChase.Markers
+	}
+	// A pile-up is a few kHz wide. Anything past that is a typo (Hz entered as
+	// if it were kHz), and honouring it would transmit far outside the segment.
+	if s.OffsetHz > 10000 {
+		s.OffsetHz = 10000
+	}
+	if s.OffsetHz < -10000 {
+		s.OffsetHz = -10000
+	}
+	return s
+}
+
+// rstChaseMarkerSet splits the configured markers into a comparison set.
+func rstChaseMarkerSet(markers string) map[string]bool {
+	out := map[string]bool{}
+	for _, m := range strings.FieldsFunc(markers, func(r rune) bool { return r == ',' || r == ';' || r == ' ' }) {
+		if m = strings.ToUpper(strings.TrimSpace(m)); m != "" {
+			out[m] = true
+		}
+	}
+	return out
+}
+
+// handleForeignSpot is what a skimmer's spot arrives at.
+func (a *App) handleForeignSpot(callsign string, freqHz int64) {
+	cfg := a.GetFlexRSTChase()
+	if !cfg.Enabled || a.cat == nil {
+		return
+	}
+	if !rstChaseMarkerSet(cfg.Markers)[strings.ToUpper(strings.TrimSpace(callsign))] {
+		return // an ordinary spot: another station's callsign, not a report
+	}
+	// From here on every refusal is logged. A marker WAS recognised, so the
+	// operator is entitled to know why the slice stayed where it was — silence
+	// at this point is indistinguishable from a feature that does not work.
+	if cfg.SplitOnly && !a.cat.State().Split {
+		applog.Printf("rst chase: %s marked at %s, but the radio is not in split — ignored",
+			strings.ToUpper(callsign), hzText(freqHz))
+		return
+	}
+	target := freqHz + int64(cfg.OffsetHz)
+	if target <= 0 {
+		return
+	}
+	now := time.Now()
+	rstChaseMu.Lock()
+	if now.Sub(rstChaseLast) < rstChaseMinGap {
+		rstChaseMu.Unlock()
+		return
+	}
+	if rstChaseFreq != 0 && absInt64(target-rstChaseFreq) < rstChaseMinStep {
+		rstChaseMu.Unlock()
+		return
+	}
+	rstChaseLast, rstChaseFreq = now, target
+	rstChaseMu.Unlock()
+
+	if err := a.cat.FlexDo(func(fc cat.FlexController) error {
+		return fc.SetTXSliceFrequency(target)
+	}); err != nil {
+		applog.Printf("rst chase: moving the TX slice to %s failed: %v", hzText(target), err)
+		return
+	}
+	applog.Printf("rst chase: %s marked at %s → TX slice to %s (offset %+d Hz)",
+		strings.ToUpper(callsign), hzText(freqHz), hzText(target), cfg.OffsetHz)
+}
+
+// hzText renders a frequency the way an operator reads one on a dial.
+func hzText(hz int64) string {
+	return strconv.FormatFloat(float64(hz)/1000, 'f', 3, 64) + " kHz"
+}

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 { ElecraftPanel } from '@/components/ElecraftPanel';
 import { AntGeniusPanel, type AGStatus } from '@/components/AntGeniusPanel';
 import { MotorAntennaWidget, type AntStatus } from '@/components/MotorAntennaWidget';
 import { TunerGeniusPanel, type TGStatus } from '@/components/TunerGeniusPanel';
@@ -94,7 +95,7 @@ import { ShutdownProgress } from '@/components/ShutdownProgress';
 import { ClusterGrid } from '@/components/ClusterGrid';
 import { cleanSpotter, inferSpotMode, spotModeCategory, spotStatusKey } from '@/lib/spot';
 import { applySpotDisplay, readSpotDisplayOptions, spotIsWorked, SPOT_DISPLAY_OPTIONS_EXPOSED } from '@/lib/spotDisplay';
-import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, IsNewUSCounty } from '../wailsjs/go/main/App';
+import { AnswerDecode, HaltDecodeTx, LogUIError, FlexTXOnBand, GetMatrixColors, GetRotorPresets, GetRowColors, GetSpotTTLMinutes, GetSpotMax, IsNewUSCounty } from '../wailsjs/go/main/App';
 import { applyMatrixColors } from '@/lib/matrixColors';
 import { WorkedBeforeGrid } from '@/components/WorkedBeforeGrid';
 import { NetControlPanel } from '@/components/NetControlPanel';
@@ -243,10 +244,15 @@ function fmtFreqDots(mhzStr: string): string {
 }
 
 // FreqWheelDisplay renders a frequency (MHz string) like fmtFreqDots — MHz.kHz.Hz
-// — but makes the three kHz digits scroll-sensitive: rolling the mouse wheel over
+// — and makes the kHz AND Hz digits scroll-sensitive: rolling the wheel over a
-// the hundreds / tens / units-of-kHz digit steps the frequency by 100 / 10 / 1 kHz
+// digit steps the frequency by that digit (100/10/1 kHz, then 100/10/1 Hz; up =
-// (up = wheel up). onNudge receives the delta in Hz. The MHz and Hz digits are
+// wheel up). onNudge receives the delta in Hz.
-// static (only kHz stepping was requested). Used in the header + compact top bar.
+//
+// The Hz digits were static at first, on the grounds that only kHz stepping had
+// been asked for. An FTDX101 operator put it plainly: the fine tuning is exactly
+// what a mouse is wanted for — zero-beating a CW signal or nudging onto an SSB
+// voice is a few tens of Hz, and it was the one move the display would not make.
+// The MHz digits stay static: a wheel notch that changes band is not fine tuning.
 function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.———.———' }: {
   mhz: string; onNudge: (deltaHz: number) => void; className?: string; placeholder?: string;
 }) {
@@ -256,6 +262,7 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
   const khz = frac.slice(0, 3); // [hundreds, tens, units] of kHz
   const hz = frac.slice(3, 6);
   const stepHz = [100_000, 10_000, 1_000]; // per kHz digit: 100 / 10 / 1 kHz
+  const stepHzFine = [100, 10, 1];         // per Hz digit
   return (
     <span className={className}>
       {intPart}.
@@ -267,7 +274,15 @@ function FreqWheelDisplay({ mhz, onNudge, className, placeholder = '—.——
           {d}
         </span>
       ))}
-      .{hz}
+      .
+      {hz.split('').map((d, i) => (
+        <span key={'h' + i}
+          onWheel={(e) => { if (e.ctrlKey || e.metaKey) return; e.preventDefault(); e.stopPropagation(); onNudge(e.deltaY < 0 ? stepHzFine[i] : -stepHzFine[i]); }}
+          className="cursor-ns-resize rounded-[2px] hover:bg-primary/25 transition-colors"
+          title="Scroll to change frequency">
+          {d}
+        </span>
+      ))}
     </span>
   );
 }
@@ -291,6 +306,37 @@ function shortCatError(err?: string): string {
 }
 // bandForMHz maps a dial frequency (MHz) to its ADIF band, or '' if outside
 // every known allocation (used to auto-fill the band when the freq changes).
+// A number typed into the CALLSIGN field is a QSY, not a callsign.
+//
+// It is where the hands already are: an operator watching a cluster or a
+// spotting page reads "28500" and wants to be there, and reaching for the
+// frequency box — or worse, the mouse — is the part that loses the station. So
+// the call field takes it, on Enter, and nothing else in the entry form changes.
+//
+// Two forms, and the AMBIGUOUS ones resolve to the band deliberately. "160" is
+// the 160 m band, not 160 kHz; "40" is 40 m, not 40 kHz. Neither number is a
+// frequency anyone tunes to, so reading them as bands costs nothing and reads
+// the way an operator says it out loud.
+const ENTRY_BAND_WORDS: Record<string, string> = {
+  '2200': '2200m', '630': '630m', '160': '160m', '80': '80m', '60': '60m',
+  '40': '40m', '30': '30m', '20': '20m', '17': '17m', '15': '15m', '12': '12m',
+  '10': '10m', '6': '6m', '4': '4m', '2': '2m', '70': '70cm',
+};
+
+// entryQSYCommand reads what was typed. Returns null for anything that is not
+// unambiguously one of the two — a callsign must never be mistaken for a QSY.
+function entryQSYCommand(text: string): { band?: string; hz?: number } | null {
+  const v = text.trim();
+  if (!/^\d{1,7}$/.test(v)) return null; // digits only: a callsign has letters
+  const band = ENTRY_BAND_WORDS[v];
+  if (band) return { band };
+  const khz = Number(v);
+  // 1500 kHz to 1.3 GHz: below that is not a band anyone works, above it is a
+  // typo. A bare "500" is neither a band nor a frequency, so nothing happens.
+  if (khz >= 1500 && khz <= 1_300_000) return { hz: Math.round(khz * 1000) };
+  return null;
+}
+
 function bandForMHz(mhz: number): string {
   if (!mhz || isNaN(mhz)) return '';
   const plan: [number, number, string][] = [
@@ -442,6 +488,11 @@ export default function App() {
   const { t, lang } = useI18n();
   // === Lists from settings (fallback for first paint) ===
   const [bands, setBands] = useState<string[]>(DEFAULT_BANDS);
+  // The station's satellites, for the entry form's SAT_NAME dropdown. Held HERE
+  // and not inside the panel: loadLists() already runs when Preferences close,
+  // so a list edited there reaches the field without a restart — which is what
+  // a panel reading it once at mount could not do.
+  const [satellites, setSatellites] = useState<string[]>([]);
   const [modes, setModes] = useState<string[]>(DEFAULT_MODES);
   const modesRef = useRef(modes);
   useEffect(() => { modesRef.current = modes; }, [modes]);
@@ -701,6 +752,7 @@ export default function App() {
     '15m':  { SSB: 21300000, CW: 21030000, FT8: 21074000, FT4: 21140000, RTTY: 21080000, default: 21300000 },
     '12m':  { SSB: 24950000, CW: 24910000, FT8: 24915000, FT4: 24919000, RTTY: 24920000, default: 24950000 },
     '10m':  { SSB: 28500000, CW: 28030000, FT8: 28074000, FT4: 28180000, RTTY: 28080000, default: 28500000 },
+    '4m':   { SSB: 70200000, CW: 70100000, FT8: 70154000,                               default: 70200000 },
     '6m':   { SSB: 50150000, CW: 50080000, FT8: 50313000, FT4: 50318000,                default: 50150000 },
     '2m':   { SSB: 144300000, CW: 144050000, FT8: 144174000,                            default: 144300000 },
     '70cm': { SSB: 432300000, CW: 432050000, FT8: 432174000,                            default: 432300000 },
@@ -1616,7 +1668,14 @@ export default function App() {
   const [clusterServers, setClusterServers] = useState<{ id: number; name: string; enabled: boolean; sort_order: number }[]>([]);
   // Ring buffer — only keep the last N spots; cluster firehose can be heavy.
   const [spots, setSpots] = useState<ClusterSpot[]>([]);
-  const SPOTS_CAP = 1000;
+  // How many spots the list holds. A setting rather than a constant: at a
+  // thousand, a busy evening filled the buffer in a couple of minutes, so the
+  // spot LIFETIME never had anything left to expire — the cap was deciding the
+  // lifetime. Kept in a ref as well: the append path runs inside a state updater
+  // that must not close over a stale value.
+  const [spotsCap, setSpotsCap] = useState(1000);
+  const spotsCapRef = useRef(1000);
+  useEffect(() => { spotsCapRef.current = spotsCap; }, [spotsCap]);
   // Cluster filter selections persist across restarts (writeUiPref → localStorage
   // + DB, so they also travel with a copied data/ folder). Loaders read the cache
   // synchronously at first render; a single effect below writes them back.
@@ -1861,7 +1920,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' | 'netcontrol' | 'decodes' | 'none';
+  type MainPaneKind = 'map1' | 'map2' | 'cluster' | 'worked' | 'flex' | 'recent' | 'icom' | 'yaesu' | 'elecraft' | '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');
@@ -1872,7 +1931,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 === '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 === 'netcontrol' || v === 'decodes';
     const [l, r, p3, p4, lay] = await Promise.all([
       GetUIPref('mainPaneLeft').catch(() => ''),
       GetUIPref('mainPaneRight').catch(() => ''),
@@ -1930,7 +1989,7 @@ export default function App() {
   useEffect(() => {
     setSpotStatus((prev) => {
       const keys = Object.keys(prev);
-      if (keys.length <= SPOTS_CAP * 2) return prev;
+      if (keys.length <= spotsCapRef.current * 2) return prev;
       const live = new Set(spots.map((x) => spotStatusKey(x.dx_call, x.band ?? '', x.comment ?? '', x.freq_hz)));
       // Decoded stations count as live too. They share this cache, and pruning
       // to the cluster spots alone would evict every one of them — on a busy
@@ -2441,6 +2500,9 @@ export default function App() {
   // same thing everywhere — and it gives the memory back.
   const [spotTTLMin, setSpotTTLMin] = useState(0);
   useEffect(() => { GetSpotTTLMinutes().then(setSpotTTLMin).catch(() => {}); }, [showSettings]);
+  // Same beat as the lifetime: re-read when Preferences closes, since the two
+  // settings decide between them how long a spot survives.
+  useEffect(() => { GetSpotMax().then((n: number) => { if (n > 0) setSpotsCap(n); }).catch(() => {}); }, [showSettings]);
   useEffect(() => {
     if (spotTTLMin <= 0) return; // 0 = keep until the count cap pushes them out
     const sweep = () => {
@@ -3024,6 +3086,7 @@ export default function App() {
       const l: ListsSettings = await GetListsSettings();
       setRstLists({ phone: (l as any).rst_phone ?? [], cw: (l as any).rst_cw ?? [], digital: (l as any).rst_digital ?? [] });
       if (l.bands && l.bands.length) setBands(l.bands);
+      setSatellites([...(((l as any).satellites ?? []) as string[])].filter(Boolean).sort());
       if (l.modes && l.modes.length) {
         setModePresets(l.modes);
         const names = l.modes.map((m) => m.name);
@@ -3112,6 +3175,19 @@ export default function App() {
   // Clicking a spot (cluster grid or any band map): tune the rig, set the mode,
   // fill the call, pre-fill POTA, (re)start the recording. Shared so every spot
   // source behaves identically.
+  // Single click on a cluster line: fill the callsign, nothing else.
+  //
+  // Reading the cluster means running down dozens of lines, and while a single
+  // click WORKED the spot every pass dragged the radio with it — one stray click
+  // while looking took the operator off the station they were working. Looking
+  // and going are two different intentions, so they are now two gestures: click
+  // to look the call up, double-click to go there.
+  function handleSpotSelect(s: any) {
+    if (!s?.dx_call?.trim()) return;
+    onCallsignInput(s.dx_call, { force: true });
+    applySpotPOTA((s as any).pota_ref);
+  }
+
   function handleSpotClick(s: any) {
     const m = inferSpotMode(s.comment ?? '', s.freq_hz);
     // Reflect the spot's freq/band in the entry strip IMMEDIATELY (optimistic),
@@ -3418,7 +3494,8 @@ export default function App() {
           const filtered = hist(sp) ? next : next.filter((x) => hist(x) || key(x) !== k);
           next = [sp, ...filtered];
         }
-        return next.length > SPOTS_CAP ? next.slice(0, SPOTS_CAP) : next;
+        const cap = spotsCapRef.current;
+        return next.length > cap ? next.slice(0, cap) : next;
       });
     };
     const unsubSpot = EventsOn('cluster:spot', (sp: ClusterSpot) => {
@@ -4117,6 +4194,41 @@ export default function App() {
     setLookupResult(null);
   }
 
+  // The Settings dialog is memoised (see SettingsModal), which only helps while
+  // its props hold still. These three would otherwise be new functions on every
+  // App render — several times a second with a cluster running — and the memo
+  // would compare unequal every time and re-render the whole panel anyway.
+  const openEditRef = useRef<(id: number) => void>(() => {});
+  // Refreshed on every render, read only when Settings opens: the dialog gets a
+  // callback whose identity never changes, and still calls the current one.
+  useEffect(() => { openEditRef.current = (id: number) => { void openEdit(id); }; });
+  // The stable wrapper the dialog actually receives.
+  const openQSOFromSettings = useCallback((id: number) => openEditRef.current(id), []);
+  const closeSettings = useCallback(() => {
+    setShowSettings(false);
+    setSettingsSection(undefined);
+    refreshChaseNew();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onSettingsSaved = useCallback(() => {
+    loadStation(); loadLists(); loadCATCfg(); reloadWk(); refreshManualRecReady();
+    // Drop the cached spot statuses. They are computed once per call+band+mode
+    // and never expire, so a rule change in Settings — grouping the digital
+    // modes into one slot, above all — left every spot already on screen
+    // showing the answer to the OLD question.
+    setSpotStatus({});
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onSettingsPaneChanged = useCallback((side: 'left' | 'right' | 'p3' | 'p4' | 'layout', v: string) => {
+    // Applied from the CHOSEN value, never from a re-read of the DB: the write
+    // is async and the layout must not lag a click behind.
+    if (side === 'left') setMainPaneLeft(v as MainPaneKind);
+    else if (side === 'right') setMainPaneRight(v as MainPaneKind);
+    else if (side === 'p3') setMainPane3(v as MainPaneKind);
+    else if (side === 'p4') setMainPane4(v as MainPaneKind);
+    else if (side === 'layout') setMainLayout4(v === 'cols' ? 'cols' : 'quad');
+  }, []);
+
   async function openEdit(id: number) {
     try { setEditingQSO(await GetQSO(id)); }
     catch (e: any) { setError(String(e?.message ?? e)); }
@@ -5468,6 +5580,25 @@ export default function App() {
     noteManualEdit();
     SetCATFrequency(Math.round(mhz * 1_000_000)).catch(() => {});
   };
+  // Carry out what was typed in the call field. Bands go through the ordinary
+  // band change, so the antennas, the power table and the outbound integrations
+  // all hear about it exactly as they would from the dropdown.
+  const applyEntryQSY = (q: { band?: string; hz?: number }) => {
+    if (q.band) {
+      onBandUserChange(q.band);
+      showToast(q.band);
+      return;
+    }
+    const hz = q.hz ?? 0;
+    if (hz <= 0) return;
+    noteManualEdit();
+    setFreqMhz((hz / 1_000_000).toFixed(6));
+    const b = bandForMHz(hz / 1_000_000);
+    if (b) setBand(b);
+    if (catState.enabled && catState.connected) SetCATFrequency(hz).catch(() => {});
+    showToast((hz / 1_000_000).toFixed(3) + ' MHz');
+  };
+
   // Mouse-wheel over a kHz digit of the top frequency readout: step the frequency
   // and (if CAT is connected) QSY the rig. The display updates optimistically on
   // every notch; the actual radio tune is debounced so a fast scroll doesn't flood
@@ -6008,7 +6139,7 @@ export default function App() {
             </div>
             <div className="flex-1 min-h-0 flex">
               <div className="flex-1 min-w-0 flex flex-col min-h-0">
-                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} />
+                <ClusterGrid key={`clg-${activeProfileId ?? 'x'}`} rows={clusterRenderedRows as any} spotStatus={spotStatus} onSpotClick={handleSpotClick} onSpotSelect={handleSpotSelect} />
               </div>
               {clusterShowFilters && renderClusterFilters()}
             </div>
@@ -6037,6 +6168,12 @@ export default function App() {
             <YaesuPanel onReportRST={(r) => { setRstSent(r); rstUserEditedRef.current = true; }} onKeySpeed={setCWSpeedEverywhere} />
           </div>
         );
+      case 'elecraft':
+        return (
+          <div className="h-full w-full min-h-0 rounded-lg overflow-hidden border border-border">
+            <ElecraftPanel 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">
@@ -6828,6 +6965,16 @@ export default function App() {
         onKeyDown={(e) => {
           if (e.key === 'Enter' && (e.target as HTMLElement).tagName === 'INPUT') {
             e.preventDefault();
+            // A number in the call field is a QSY. Checked BEFORE ESM and before
+            // logging: both would otherwise act on a "callsign" of 28500.
+            if (e.target === callsignRef.current) {
+              const q = entryQSYCommand(callsignRef.current?.value ?? '');
+              if (q) {
+                applyEntryQSY(q);
+                setCallsign(''); // the field goes back to what it is for
+                return;
+              }
+            }
             // ESM (Enter Sends Message): fire the stage-appropriate CW macro instead
             // of logging. Falls through to the normal log when ESM isn't active.
             if (esmHandleEnter(e.target as HTMLElement)) return;
@@ -6945,6 +7092,7 @@ export default function App() {
             band={band}
             mode={mode}
             bands={bands}
+            satellites={satellites}
             onEditQso={openEdit}
             {...(!callsign.trim() && selQso ? {
               slotCall: selQso.call, slotBand: selQso.band, slotMode: selQso.mode,
@@ -7303,6 +7451,7 @@ export default function App() {
               {catState.backend === 'flex' && <TabsTrigger value="flex">Flex Console</TabsTrigger>}
               {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>}
               {statsTabOpen && (
                 <TabsTrigger value="stats" className="gap-1.5">
                   {t('stats.tab')}
@@ -7669,6 +7818,7 @@ export default function App() {
                     rows={rendered as any}
                     spotStatus={spotStatus}
                     onSpotClick={handleSpotClick}
+                    onSpotSelect={handleSpotSelect}
                   />
                 );
               })()}
@@ -7982,6 +8132,14 @@ export default function App() {
               </TabsContent>
             )}
 
+            {/* Elecraft K3/K4 console. Shown for the Kenwood backend too: the
+                K3 speaks that dialect and the panel reads whatever answers. */}
+            {(catState.backend === 'elecraft' || catState.backend === 'kenwood') && (
+              <TabsContent value="elecraft" className="flex-1 min-h-0 p-0">
+                <ElecraftPanel 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; }} />
@@ -8372,25 +8530,11 @@ export default function App() {
 
       {showSettings && (
         <SettingsModal
+          onEditQSO={openQSOFromSettings}
           initialSection={settingsSection}
-          onClose={() => { setShowSettings(false); setSettingsSection(undefined); refreshChaseNew(); }}
+          onClose={closeSettings}
-          onSaved={() => {
+          onSaved={onSettingsSaved}
-            loadStation(); loadLists(); loadCATCfg(); reloadWk(); refreshManualRecReady();
+          onMainPaneChanged={onSettingsPaneChanged}
-            // Drop the cached spot statuses. They are computed once per
-            // call+band+mode and never expire, so a rule change in Settings —
-            // grouping the digital modes into one slot, above all — left every
-            // spot already on screen showing the answer to the OLD question.
-            setSpotStatus({});
-          }}
-          onMainPaneChanged={(side, v) => {
-            // Applied from the CHOSEN value, never from a re-read of the DB:
-            // the write is async and the layout must not lag a click behind.
-            if (side === 'left') setMainPaneLeft(v as MainPaneKind);
-            else if (side === 'right') setMainPaneRight(v as MainPaneKind);
-            else if (side === 'p3') setMainPane3(v as MainPaneKind);
-            else if (side === 'p4') setMainPane4(v as MainPaneKind);
-            else if (side === 'layout') setMainLayout4(v === 'cols' ? 'cols' : 'quad');
-          }}
           flexAvailable={catState.backend === 'flex'}
           icomAvailable={catState.backend === 'icom'}
           yaesuAvailable={catState.backend === 'yaesu'}

frontend/src/components/AwardRefSelector.tsx

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

frontend/src/components/ClusterGrid.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import {
   AllCommunityModule, ModuleRegistry,
-  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent,
+  type ColDef, type ColumnState, type GridReadyEvent, type RowClickedEvent, type RowDoubleClickedEvent,
 } from 'ag-grid-community';
 import { hamlogGridTheme } from '@/lib/gridTheme';
 import { AgGridReact } from 'ag-grid-react';
@@ -75,7 +75,13 @@ export type SpotStatusEntry = {
 type Props = {
   rows: ClusterSpot[];
   spotStatus: Record<string, SpotStatusEntry>;
+  // A DOUBLE click works the spot: QSY, mode, callsign, the lot.
   onSpotClick?: (s: ClusterSpot) => void;
+  // A SINGLE click only fills the callsign. Reading the cluster means passing
+  // over dozens of lines, and every pass used to drag the radio with it — one
+  // stray click while looking took the operator off the station they were
+  // working. Looking and going are now two different gestures.
+  onSpotSelect?: (s: ClusterSpot) => void;
 };
 
 const COL_STATE_KEY = 'hamlog.clusterColState.v1';
@@ -500,7 +506,7 @@ const GROUP_ORDER = ['Spot', 'Geo'];
 const CLG_GRP_KEYS: Record<string, string> = { Spot: 'clg2.grpSpot', Geo: 'clg2.grpGeo' };
 const groupLabel = (t: TFn, g: string): string => t(CLG_GRP_KEYS[g] ?? g);
 
-export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
+export function ClusterGrid({ rows, spotStatus, onSpotClick, onSpotSelect }: Props) {
   const { t } = useI18n();
   const gridRef = useRef<any>(null);
   const [pickerOpen, setPickerOpen] = useState(false);
@@ -582,7 +588,49 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
     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);
+  }
+
+  function handleRowDoubleClicked(e: RowDoubleClickedEvent<ClusterSpot>) {
     if (e.data && onSpotClick) onSpotClick(e.data);
   }
 
@@ -636,7 +684,7 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
           <AgGridReact<ClusterSpot>
             ref={gridRef}
             theme={hamlogTheme}
-            rowData={rows}
+            rowData={shown}
             columnDefs={columnDefs}
             defaultColDef={defaultColDef}
             context={context}
@@ -647,11 +695,21 @@ export function ClusterGrid({ rows, spotStatus, onSpotClick }: Props) {
             onColumnVisible={saveColumnState}
             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

@@ -0,0 +1,326 @@
+import { useEffect, useRef, useState } from 'react';
+import { Radio, Power, Activity, AudioLines, SlidersHorizontal } from 'lucide-react';
+import {
+  GetKenwoodState, RefreshKenwood, SetKenwoodPower, SetKenwoodAFGain, SetKenwoodTX, TuneKenwoodATU,
+  SetKenwoodRFGain, SetKenwoodMicGain, SetKenwoodSquelch, SetKenwoodPreamp, SetKenwoodAtt,
+  SetKenwoodNB, SetKenwoodNR, SetKenwoodAGC, SetKenwoodFilter, SetKenwoodAntenna,
+  SetKenwoodRIT, SetKenwoodXIT, ClearKenwoodRIT, SetKenwoodKeySpeed, ToggleKenwoodATU, NudgeKenwoodRIT,
+  GetCATState,
+} 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';
+
+type KenwoodState = {
+  available: boolean; model?: string; elecraft: boolean; mode?: string;
+  transmitting: boolean; split: boolean; split_tx_hz?: number;
+  s_meter: number; s_meter_raw: number;
+  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; rit_offset: number; key_speed: number;
+  meters_provisional: boolean;
+};
+
+const ZERO: KenwoodState = {
+  available: false, elecraft: false, transmitting: false, split: false,
+  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, 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.
+// 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
+// scaling: the raw value is on screen and in the log, so a real radio settles
+// it rather than this comment.
+const S9_RAW = 9;
+const DB_PER_RAW = 6;
+function sParts(rawV: number): { s: number; over: number; label: string } {
+  if (rawV >= S9_RAW) {
+    const over = Math.max(0, Math.round((rawV - S9_RAW) * DB_PER_RAW));
+    return { s: 9, over, label: over > 0 ? `S9+${over}` : 'S9' };
+  }
+  const s = Math.max(0, Math.min(9, rawV));
+  return { s, over: 0, label: `S${s}` };
+}
+
+// Segment colour, printed the way a radio's own meter is: green up to S9, amber
+// through the S9+ range, red once the signal would be reported as 59+20 or more.
+function sSegColor(frac: number) {
+  if (frac > 0.78) return '#dc2626';
+  if (frac > 0.55) return '#f59e0b';
+  return '#16a34a';
+}
+
+// The card shell the Yaesu and Icom consoles use, so the three read alike.
+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, so the panel reads as one
+// instrument instead of a collection of differently-styled switches.
+function Toggle({ label, on, off, onClick }: { label: string; on: boolean; off: boolean; onClick: () => void }) {
+  return (
+    <button type="button" disabled={off} onClick={onClick}
+      className={cn('px-2 py-1 rounded-md text-[11px] font-bold tracking-wide border transition-all disabled:opacity-30',
+        on ? 'bg-primary text-primary-foreground border-primary' : 'bg-card text-muted-foreground border-border hover:border-primary/60')}>
+      {label}
+    </button>
+  );
+}
+
+export function ElecraftPanel({ onReportRST }: { onReportRST?: (rst: string) => void }) {
+  const { t } = useI18n();
+  const [st, setSt] = useState<KenwoodState>(ZERO);
+  const [freqHz, setFreqHz] = useState(0);
+  const [err, setErr] = useState('');
+  // Optimistic overlay: a slider must follow the finger, not the poll. Dropped
+  // once the radio has had time to answer with the value it actually took.
+  const [local, setLocal] = useState<{ rf_power?: number; af_gain?: number; rf_gain?: number; mic_gain?: number; squelch?: number; key_speed?: number }>({});
+  const localAtRef = useRef(0);
+
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const s = (await GetKenwoodState()) as KenwoodState;
+        const c = (await GetCATState()) as any;
+        if (!alive) return;
+        setSt(s);
+        setFreqHz(c?.split && c?.freq_rx_hz > 0 ? c.freq_rx_hz : (c?.freq_hz ?? 0));
+        if (Date.now() - localAtRef.current > 1200) setLocal({});
+        setErr('');
+      } catch (e: any) {
+        if (alive) setErr(String(e?.message ?? e));
+      }
+    };
+    tick();
+    const id = window.setInterval(tick, 500);
+    return () => { alive = false; window.clearInterval(id); };
+  }, []);
+
+  const view = { ...st, ...local };
+  const off = !st.available;
+
+  const setErrMsg = (e: any) => setErr(String(e?.message ?? e));
+
+  const put = (patch: typeof local, run: () => Promise<any>) => {
+    setLocal((p) => ({ ...p, ...patch }));
+    localAtRef.current = Date.now();
+    run().catch((e) => setErr(String(e?.message ?? e)));
+  };
+
+  return (
+    <div className="h-full min-h-0 overflow-auto bg-background">
+      {/* Same wrapper as the Yaesu, Icom and Flex consoles: capped width and
+          CENTRED. A console stretched across a 2000 px window puts a slider a
+          hand's width from its own label, and the panel stops reading as one
+          instrument. */}
+      <div className="max-w-5xl mx-auto p-3 space-y-3">
+      {/* VFO + status */}
+      <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.elecraft ? 'Elecraft' : 'Kenwood'} {st.model}
+            <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>
+        <button type="button" className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
+          onClick={() => RefreshKenwood().catch(() => {})} title={t('k3.refreshHint')}>
+          <SlidersHorizontal className="size-3.5" />
+        </button>
+      </div>
+
+      {off && <div className="text-xs text-muted-foreground px-1">{t('k3.waiting')}</div>}
+      {!!err && <div className="text-[11px] text-danger px-1">{err}</div>}
+
+      {/* Meters */}
+      <Card icon={Activity} title={t('k3.meters')}>
+      <div className="grid grid-cols-1 sm:grid-cols-3 gap-2">
+        <MeterBar label="S-METER" value={view.transmitting ? 0 : view.s_meter} lo={0} hi={100}
+          accent="#16a34a" segColor={sSegColor}
+          display={view.transmitting ? '—' : sParts(view.s_meter_raw).label}
+          onClick={() => {
+            if (view.transmitting || !onReportRST) return;
+            const sp = sParts(view.s_meter_raw);
+            onReportRST(sMeterRST(sp.s, sp.over, view.mode));
+          }}
+          title={t('k3.sMeterHint', { raw: String(view.s_meter_raw) })} />
+        <MeterBar label="PWR" value={view.transmitting ? view.power_meter : 0} lo={0} hi={100} accent="#0ea5e9" />
+        {/* 0 means "not measured", and it must not render as a perfect 1.0:
+            a match that looks ideal on an antenna nobody has measured is the one
+            reading that can cost a radio. */}
+        <MeterBar label="SWR" value={view.transmitting && view.swr > 0 ? view.swr : 1} lo={1} hi={4}
+          accent="#f59e0b"
+          display={view.transmitting && view.swr > 0 ? view.swr.toFixed(1) : '—'} />
+      </div>
+      {view.meters_provisional && (
+        <p className="text-[10px] text-muted-foreground">{t('k3.provisional')}</p>
+      )}
+      </Card>
+
+      {/* MOX + TUNE */}
+      <div className="flex items-center gap-2">
+        <button type="button" disabled={off}
+          onClick={() => SetKenwoodTX(!view.transmitting).catch((e) => setErr(String(e?.message ?? e)))}
+          className={cn('flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+            view.transmitting
+              ? 'bg-danger text-danger-foreground border-danger shadow-[0_0_14px] shadow-danger/50'
+              : 'bg-card text-danger border-danger hover:bg-danger-muted')}>
+          <Power className="size-4 inline mr-1 -mt-0.5" /> MOX
+        </button>
+        <button type="button" disabled={off}
+          onClick={() => TuneKenwoodATU().catch((e) => setErr(String(e?.message ?? e)))}
+          title={t('k3.tuneHint')}
+          className="flex-1 px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-warning text-warning bg-card hover:bg-warning-muted transition-all disabled:opacity-30">
+          <Activity className="size-4 inline mr-1 -mt-0.5" /> TUNE
+        </button>
+        {/* The HOLD of the same switch: tuner in line or bypassed. Two buttons
+            because they are two things on the radio — tuning is a cycle you
+            start, bypassing is a state you leave it in. */}
+        <button type="button" disabled={off}
+          onClick={() => ToggleKenwoodATU().catch(setErrMsg)}
+          title={t('k3.atuHint')}
+          className="px-3 py-2.5 rounded-lg text-sm font-extrabold tracking-wide border-2 border-border text-muted-foreground bg-card hover:bg-muted transition-all disabled:opacity-30">
+          ATU
+        </button>
+      </div>
+
+      {/* Levels — two columns, so a slider stays beside the label it belongs to
+          instead of running the width of the window. */}
+      <Card icon={SlidersHorizontal} title={t('k3.levels')}>
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-x-6 gap-y-2">
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.power')}</span>
+          <WheelRange min={0} max={110} step={5} disabled={off}
+            value={view.rf_power ?? 0}
+            onChange={(n) => put({ rf_power: n }, () => SetKenwoodPower(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_power ?? 0} W</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground flex items-center gap-1">
+            <AudioLines className="size-3.5" /> {t('k3.volume')}
+          </span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.af_gain ?? 0}
+            onChange={(n) => put({ af_gain: n }, () => SetKenwoodAFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.af_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.rfGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.rf_gain ?? 0}
+            onChange={(n) => put({ rf_gain: n }, () => SetKenwoodRFGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.rf_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.micGain')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.mic_gain ?? 0}
+            onChange={(n) => put({ mic_gain: n }, () => SetKenwoodMicGain(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.mic_gain ?? 0}</span>
+        </label>
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.squelch')}</span>
+          <WheelRange min={0} max={100} disabled={off}
+            value={view.squelch ?? 0}
+            onChange={(n) => put({ squelch: n }, () => SetKenwoodSquelch(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.squelch ?? 0}</span>
+        </label>
+        {/* CW keyer speed — the radio's own keyer, the one the K3 sends with. */}
+        <label className="flex items-center gap-2 text-xs">
+          <span className="w-16 shrink-0 text-muted-foreground">{t('k3.keySpeed')}</span>
+          <WheelRange min={8} max={50} disabled={off}
+            value={view.key_speed || 20}
+            onChange={(n) => put({ key_speed: n }, () => SetKenwoodKeySpeed(n))} />
+          <span className="w-12 text-right font-mono tabular-nums">{view.key_speed || 0} wpm</span>
+        </label>
+      </div>
+      </Card>
+
+      {/* Receive chain. Toggles, because that is what they are on the radio:
+          one press each, and the state comes back from the rig rather than from
+          what the button was asked to do. */}
+      <Card icon={AudioLines} title={t('k3.receive')}>
+      <div className="space-y-2">
+        <div className="flex flex-wrap items-center gap-1.5">
+          <Toggle label="PRE" on={view.preamp} off={off} onClick={() => SetKenwoodPreamp(!view.preamp).catch(setErrMsg)} />
+          <Toggle label="ATT" on={view.att} off={off} onClick={() => SetKenwoodAtt(!view.att).catch(setErrMsg)} />
+          <Toggle label="NB" on={view.nb} off={off} onClick={() => SetKenwoodNB(!view.nb).catch(setErrMsg)} />
+          <Toggle label="NR" on={view.nr} off={off} onClick={() => SetKenwoodNR(!view.nr).catch(setErrMsg)} />
+          <span className="w-2" />
+          {['OFF', 'SLOW', 'FAST'].map((a) => (
+            <Toggle key={a} label={a} on={(view.agc || '').toUpperCase() === a} off={off}
+              onClick={() => SetKenwoodAGC(a).catch(setErrMsg)} />
+          ))}
+        </div>
+
+        {/* RIT / XIT. Clear zeroes both offsets at once — the radio's own RC,
+            and what an operator means by "clear it". */}
+        <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. */}
+          {view.antenna > 0 && (<>
+            <span className="w-2" />
+            <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.antenna')}</span>
+            {[1, 2].map((n) => (
+              <Toggle key={n} label={'ANT' + n} on={view.antenna === n} off={off}
+                onClick={() => SetKenwoodAntenna(n).catch(setErrMsg)} />
+            ))}
+          </>)}
+        </div>
+
+        {/* Filter width */}
+        <div className="flex flex-wrap items-center gap-1.5">
+          <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{t('k3.filter')}</span>
+          {FILTERS.map((hz) => (
+            <Toggle key={hz} label={hz >= 1000 ? (hz / 1000).toFixed(1) + 'k' : String(hz)}
+              on={view.filter_hz === hz} off={off}
+              onClick={() => SetKenwoodFilter(hz).catch(setErrMsg)} />
+          ))}
+          {view.filter_hz > 0 && (
+            <span className="text-[10px] font-mono text-muted-foreground">{view.filter_hz} Hz</span>
+          )}
+        </div>
+      </div>
+      </Card>
+      </div>
+    </div>
+  );
+}

frontend/src/components/FlexPanel.tsx

@@ -8,6 +8,7 @@ import {
   GetTunerGeniusStatus, GetTunerGeniusSettings,
   GetAmpStatuses, AmpOperate, AmpPower, AmpPowerLevel,
   FlexSetAGCMode, FlexSetAGCThreshold, FlexSetAudioLevel, FlexSetMute, FlexSetRXAntenna, FlexSetTXAntenna, FlexSetSplit, FlexSetActiveSlice, FlexSetTXSlice,
+  GetFlexRSTChase, SaveFlexRSTChase, SetFlexRSTChaseEnabled,
   FlexSetRIT, FlexSetRITFreq, FlexSetXIT, FlexSetXITFreq,
   FlexSetNB, FlexSetNBLevel, FlexSetNR, FlexSetNRLevel, FlexSetANF, FlexSetANFLevel,
   FlexSetLMSNR, FlexSetLMSNRLevel, FlexSetLMSANF, FlexSetLMSANFLevel,
@@ -304,6 +305,25 @@ function powerLevelLabel(pl?: string): string {
 // host can keep the WinKeyer (which actually sends the macros) in sync.
 export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number) => void; onReportRST?: (rst: string) => void } = {}) {
   const { t } = useI18n();
+  // Split-pile-up chaser (see flexrstchase.go). Held here so the button can
+  // paint its state without polling the backend for it.
+  const [rstChase, setRstChase] = useState<{ enabled: boolean; markers: string; offset_hz: number; split_only: boolean }>(
+    { enabled: false, markers: '599', offset_hz: 0, split_only: true });
+  const [rstChaseOffsetText, setRstChaseOffsetText] = useState('0');
+  // The marker text is edited as raw text and only parsed on blur: it is a
+  // comma-separated list, and normalising it on every keystroke would eat the
+  // comma the moment it is typed.
+  const [rstChaseMarkersText, setRstChaseMarkersText] = useState('599');
+  // The marker field is summoned by right-clicking the button, not parked on
+  // the row: it is set once to agree with SDC and then never touched, while the
+  // row it was sitting in is the busiest in the panel.
+  const [rstChaseEditing, setRstChaseEditing] = useState(false);
+  useEffect(() => {
+    GetFlexRSTChase().then((c: any) => {
+      if (!c) return;
+      setRstChase(c); setRstChaseOffsetText(String(c.offset_hz ?? 0)); setRstChaseMarkersText(String(c.markers ?? '599'));
+    }).catch(() => {});
+  }, []);
   const [st, setSt] = useState<FlexState>(ZERO);
   // Extra/"advanced" DSP rows (WNB + the SmartSDR v4 NRL/NRS/NRF/ANFL/AI-FFT
   // block) collapse behind a button so the RECEIVE card doesn't grow tall — only
@@ -652,6 +672,64 @@ export function FlexPanel({ onCWSpeed, onReportRST }: { onCWSpeed?: (wpm: number
                   st.split ? 'bg-info text-info-foreground border-info shadow-[0_0_12px] shadow-info/50' : 'bg-card text-info border-info hover:bg-info-muted')}>
                 SPLIT
               </button>
+              {/* The split chaser. On the panel and not in a settings page:
+                  it is switched on when a DXpedition appears and off when it is
+                  in the log, which is done mid-QSO with one hand. The offset
+                  sits beside it because it is the one number retuned while
+                  chasing — everything else about the feature is configured once. */}
+              {/* CW ONLY. The marker comes from a skimmer decoding a CW report,
+                  so on SSB or FT8 there is nothing to chase — and a switch that
+                  cannot fire is an invitation to wonder why it does nothing. */}
+              {isCW && (<>
+              <button type="button" disabled={off}
+                title={t('flxp.rstChaseHint', { m: rstChase.markers })}
+                onContextMenu={(e) => { e.preventDefault(); setRstChaseEditing(true); }}
+                onClick={() => { const on = !rstChase.enabled; setRstChase({ ...rstChase, enabled: on }); SetFlexRSTChaseEnabled(on).catch(() => {}); }}
+                className={cn('px-3 py-1.5 rounded-lg text-sm font-extrabold tracking-wide border-2 transition-all disabled:opacity-30',
+                  rstChase.enabled ? 'bg-success text-success-foreground border-success shadow-[0_0_12px] shadow-success/50' : 'bg-card text-success border-success hover:bg-success-muted')}>
+                {rstChase.markers.split(',')[0].trim() || '599'}
+              </button>
+              {/* The marker is whatever SDC was told to write — "599", "5NN", or
+                  several. It has to agree with the skimmer or nothing ever fires,
+                  so it is edited here rather than in a settings page — but only
+                  when asked for, since it is set once and then left alone. */}
+              {rstChaseEditing && (
+                <input type="text" autoFocus value={rstChaseMarkersText}
+                  onChange={(e) => setRstChaseMarkersText(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === 'Enter') (e.target as HTMLInputElement).blur();
+                    if (e.key === 'Escape') { setRstChaseMarkersText(rstChase.markers); setRstChaseEditing(false); }
+                  }}
+                  onBlur={() => {
+                    const v = rstChaseMarkersText.trim() || '599';
+                    setRstChaseMarkersText(v);
+                    setRstChaseEditing(false);
+                    if (v === rstChase.markers) return;
+                    const next = { ...rstChase, markers: v };
+                    setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                  }}
+                  title={t('flxp.rstChaseMarkerHint')}
+                  className="w-16 h-6 rounded border border-input bg-background px-1 text-[11px] font-mono uppercase" />
+              )}
+              {rstChase.enabled && (
+                <label className="flex items-center gap-1 text-[11px] text-muted-foreground whitespace-nowrap ml-2">
+                  {t('flxp.rstChaseOffset')}
+                  <input type="number" step={10} value={rstChaseOffsetText}
+                    onChange={(e) => setRstChaseOffsetText(e.target.value)}
+                    onBlur={() => {
+                      // Kept as text while typing: normalising every keystroke
+                      // makes a minus sign impossible to enter.
+                      const n = Math.round(Number(rstChaseOffsetText));
+                      const v = Number.isFinite(n) ? n : 0;
+                      setRstChaseOffsetText(String(v));
+                      const next = { ...rstChase, offset_hz: v };
+                      setRstChase(next); SaveFlexRSTChase(next as any).catch(() => {});
+                    }}
+                    className="w-16 h-6 rounded border border-input bg-background px-1.5 text-[11px] font-mono" />
+                  Hz
+                </label>
+              )}
+              </>)}
               {st.split && !!st.tx_freq_hz && (
                 <span className="text-[11px] font-mono text-muted-foreground whitespace-nowrap">
                   TX {(st.tx_freq_hz / 1e6).toFixed(3)}

frontend/src/components/QSLManagerModal.tsx

@@ -8,7 +8,7 @@ import {
   Select, SelectTrigger, SelectValue, SelectContent, SelectItem,
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
-import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, OpenADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
+import { FindQSOsForUpload, UploadQSOsManual, DownloadConfirmations, CancelConfirmations, ImportHamlogConfirmations, ExportHamlogUnmatched, OpenADIFFile, SaveADIFFile, SyncPOTAHunterLog, ListQSO, BulkUpdateQSL, UploadCallsign, GetSlotStats } from '../../wailsjs/go/main/App';
 import { Input } from '@/components/ui/input';
 import { RecentQSOsGrid } from '@/components/RecentQSOsGrid';
 import { EventsOn } from '../../wailsjs/runtime/runtime';
@@ -363,6 +363,21 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
     catch (e: any) { setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setBusy(false); }
   }
 
+  // The unmatched half of an import. Offered as a file because a few hundred
+  // discrepancies are a list to work through, not something to read in a log
+  // window.
+  async function exportHamlogUnmatched() {
+    try {
+      const path = await SaveADIFFile();
+      if (!path) return;
+      const n = await ExportHamlogUnmatched(path);
+      setLogLines((p) => [...p, `Exported ${n} unmatched confirmation(s) → ${path}`]);
+      setShowLog(true);
+    } catch (e: any) {
+      setLogLines((p) => [...p, 'Error: ' + String(e?.message ?? e)]); setShowLog(true);
+    }
+  }
+
   function viewResults() {
     setShowLog(false);
     if (logAction === 'upload') selectRequired();
@@ -680,10 +695,16 @@ export function QSLManagerPanel({ onEditQSO, actions, paperRequest }: {
       <div className="flex items-center justify-between gap-2 px-3 py-2 border-t border-border bg-muted/20 shrink-0">
         <div className="flex items-center gap-2 flex-wrap">
           {service === 'hamlog' ? (
+            <>
             <Button variant="outline" size="sm" onClick={importHamlogCfm} disabled={busy}
               title={t('qslm.hamlogImportTitle')}>
               <DownloadCloud className="size-3.5" /> {t('qslm.hamlogImportCfm')}
             </Button>
+            <Button variant="outline" size="sm" onClick={exportHamlogUnmatched} disabled={busy}
+              title={t('qslm.hamlogUnmatchedTitle')}>
+              <UploadCloud className="size-3.5 rotate-180" /> {t('qslm.hamlogUnmatched')}
+            </Button>
+            </>
           ) : (
           <Button variant="outline" size="sm" onClick={download} disabled={busy}
             title={t('qslm.downloadTitle')}>

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,
@@ -58,7 +58,7 @@ import {
   GetFolderSync, SaveFolderSync, PickFolderSyncFolder, GetFolderSyncStatus, SyncFolderNow,
   GetRelayAuto, SaveRelayAuto, GetStationDevices,
   GetAwardDefs, GetTrackedAwards, SaveTrackedAwards,
-  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes,
+  GetBandOpenSettings, SaveBandOpenSettings, GetGridScopeSettings, SaveGridScopeSettings, GetPSKReporterStatus, GetChaseNewGrids, SetChaseNewGrids, GetChaseNew, SetChaseNew, GetGridCacheStatus, GetLinkedAmps, SetLinkedAmps, GetSpotTTLMinutes, SetSpotTTLMinutes, GetSpotMax, SetSpotMax, 
 } from '../../wailsjs/go/main/App';
 import type { profile as profileModels } from '../../wailsjs/go/models';
 import type { LookupSettingsForm, StationSettingsForm, ListsSettingsForm, ModePresetForm } from '@/types';
@@ -80,7 +80,6 @@ import {
 } from '@/components/ui/select';
 import { cn } from '@/lib/utils';
 import { writeUiPref } from '@/lib/uiPref';
-import { loadAutoCall, autoCallKey, type AutoCallSettings, type AutoCallCriteria } from '@/lib/autocall';
 import { getDateFormat, setDateFormat, type DateFormat } from '@/lib/dateFormat';
 import { useI18n, FlagGB, FlagFR, type Lang } from '@/lib/i18n';
 import { useTheme, CONCRETE_THEMES, type ThemeChoice } from '@/lib/theme';
@@ -176,6 +175,11 @@ interface Props {
   flexAvailable?: boolean; // CAT backend is FlexRadio → offer it as a Main pane
   icomAvailable?: boolean; // CAT backend is Icom → offer the Icom console as a Main pane
   yaesuAvailable?: boolean; // CAT backend is Yaesu → offer the Yaesu console as a Main pane
+  // Opens a QSO in the editor. Settings is not where a log is edited — but the
+  // RDA comparison lists contacts whose district is in dispute, and a list of
+  // things to fix that cannot be acted on is a list to write down and look up
+  // again later.
+  onEditQSO?: (id: number) => void;
 }
 
 // Pretty little card showing what OpsLog will stamp on each QSO based on
@@ -201,6 +205,7 @@ type SectionId =
   | 'lookup'
   | 'lists-bands'
   | 'lists-modes'
+  | 'lists-satellites'
   | 'cluster'
   | 'backup'
   | 'database'
@@ -311,6 +316,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
       { kind: 'group', label: t('nav.lists'), icon: Database, defaultOpen: true, children: [
         { kind: 'item', label: t('sec.bands'),      id: 'lists-bands' },
         { kind: 'item', label: t('sec.modes'), id: 'lists-modes' },
+        { kind: 'item', label: t('sec.satellites'), id: 'lists-satellites' },
       ]},
       { kind: 'item', label: t('sec.cluster'),     id: 'cluster' },
       { kind: 'item', label: t('sec.udp'), id: 'udp' },
@@ -340,7 +346,7 @@ function buildTree(flexAvailable: boolean, t: (k: string) => string): TreeNode[]
 // Map section id → i18n key (breadcrumb / placeholders).
 const SECTION_KEY: Partial<Record<SectionId, string>> = {
   station: 'sec.station', profiles: 'sec.profiles', operating: 'sec.operating', confirmations: 'sec.confirmations',
-  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes',
+  'external-services': 'sec.external', appearance: 'sec.appearance', lookup: 'sec.lookup', 'lists-bands': 'sec.bands', 'lists-modes': 'sec.modes', 'lists-satellites': 'sec.satellites',
   cluster: 'sec.cluster', backup: 'sec.backup', database: 'sec.database', autostart: 'sec.autostart', udp: 'sec.udp',
   adifmon: 'sec.adifmon',
   foldersync: 'sec.foldersync',
@@ -362,6 +368,7 @@ const SECTION_LABELS: Partial<Record<SectionId, string>> = {
   lookup: 'Callsign Lookup',
   'lists-bands': 'Bands',
   'lists-modes': 'Modes & default RST',
+  'lists-satellites': 'Satellites',
   cluster: 'DX Cluster',
   backup: 'Database backup',
   database: 'Database',
@@ -1477,7 +1484,59 @@ const ICOM_MODELS: { name: string; addr: number }[] = [
   { name: 'IC-9700', addr: 0xA2 },
 ];
 
-export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable }: Props) {
+// The radios OpsLog talks to, by BRAND, and the ways each one can be reached.
+//
+// Three connections exist in the world and each brand has its own subset:
+//   usb    — a COM port, the radio's own USB or a serial cable
+//   bridge — RS-232 carried over Ethernet by a serial bridge (ser2net, an
+//            Ethernet-serial box): the SAME CAT bytes, a socket instead of wire
+//   native — the manufacturer's own network protocol, a session of its own
+//
+// The backend NAME stored in settings is unchanged — 'icom-net' is still
+// 'icom-net' — because a settings file written by an older build has to keep
+// working. This table is only how the two questions map onto it.
+// OmniRig leads — it is the one that works with any radio, so it is where
+// someone who does not find their rig below should land. The rest are
+// alphabetical, because a list of brands has no other defensible order.
+const CAT_BRANDS: { id: string; label: string; links: string[]; backend: (link: string) => string }[] = [
+  { id: 'omnirig', label: 'OmniRig (any rig)', links: ['usb'], backend: () => 'omnirig' },
+  { id: 'elecraft', label: 'Elecraft K3 / K4', links: ['usb', 'bridge'], backend: () => 'elecraft' },
+  { id: 'tci', label: 'Expert Electronics / SunSDR (TCI)', links: ['native'], backend: () => 'tci' },
+  { id: 'flex', label: 'FlexRadio (SmartSDR)', links: ['native'], backend: () => 'flex' },
+  { id: 'icom', label: 'Icom', links: ['usb', 'native'], backend: (l) => (l === 'native' ? 'icom-net' : 'icom') },
+  { id: 'kenwood', label: 'Kenwood', links: ['usb', 'bridge'], backend: () => 'kenwood' },
+  { id: 'xiegu', label: 'Xiegu', links: ['usb'], backend: () => 'xiegu' },
+  { id: 'yaesu', label: 'Yaesu', links: ['usb'], backend: () => 'yaesu' },
+];
+
+// brandOfBackend reads the stored backend back into the two questions.
+function brandOfBackend(backend: string, kenwoodLink?: string): { brand: string; link: string } {
+  switch (backend) {
+    case 'icom-net': return { brand: 'icom', link: 'native' };
+    case 'icom': return { brand: 'icom', link: 'usb' };
+    case 'flex': return { brand: 'flex', link: 'native' };
+    case 'tci': return { brand: 'tci', link: 'native' };
+    case 'yaesu': return { brand: 'yaesu', link: 'usb' };
+    case 'xiegu': return { brand: 'xiegu', link: 'usb' };
+    case 'kenwood': case 'elecraft':
+      return { brand: backend, link: kenwoodLink || 'usb' };
+    default: return { brand: 'omnirig', link: 'usb' };
+  }
+}
+
+// SETTINGS DOES NOT RE-RENDER WITH THE MAIN WINDOW.
+//
+// It is a child of App, and App re-renders on every cluster spot, every CAT
+// status push, every decode — several times a second on a busy evening. Each of
+// those re-rendered this entire panel, which is large enough that the rebuild
+// takes longer than the gap between them: the page looked like it was
+// refreshing ten times a second and buttons stopped responding, because the
+// element under the pointer was replaced between the press and the release.
+//
+// memo() cuts that off. It only works if the props hold still, which is why
+// App passes callbacks that do not change identity on every render — see the
+// useCallback wrappers there.
+function SettingsModalImpl({ onClose, onSaved, initialSection, onMainPaneChanged, flexAvailable, icomAvailable, yaesuAvailable, onEditQSO }: Props) {
   const { t } = useI18n();
   const [selected, setSelected] = useState<SectionId>((initialSection as SectionId) || 'station');
   const [loading, setLoading] = useState(true);
@@ -1506,7 +1565,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [activeProfile, setActiveProfile] = useState<Profile | null>(null);
   const updateActive = (patch: Partial<Profile>) =>
     setActiveProfile((p) => (p ? { ...p, ...patch } : p));
-  const [lists, setLists] = useState<ListsSettings>({ bands: [], modes: [], rst_phone: [], rst_cw: [], rst_digital: [] });
+  const [lists, setLists] = useState<ListsSettings>({ bands: [], modes: [], rst_phone: [], rst_cw: [], rst_digital: [], satellites: [] });
   // RST report lists edited as free text (one/space-separated values).
   const [rstText, setRstText] = useState({ phone: '', cw: '', digital: '' });
   // Custom band drafts (catalog covers ADIF spec but the user may have
@@ -1515,12 +1574,31 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [modeDraft, setModeDraft] = useState('');
   const [catCfg, setCatCfg] = useState<CATSettings>({
     enabled: false, backend: 'omnirig', omnirig_rig: 1, omnirig_vfo: '', flex_host: '', flex_port: 4992, flex_spots: false, flex_decode_spots: false, flex_decode_secs: 120, flex_dvk_dax: false,
-    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
+    yaesu_port: '', yaesu_baud: 38400, yaesu_low_lines: false, kenwood_low_lines: false, kenwood_port: '', kenwood_baud: 9600, kenwood_host: '', kenwood_link: 'usb', kenwood_data_mode: 'usb', xiegu_port: '', xiegu_baud: 19200, xiegu_addr: 0x70, xiegu_ptt_line: '',
     icom_port: '', icom_baud: 115200, icom_addr: 0x98, icom_net_host: '', icom_net_user: '', icom_net_pass: '', icom_net_audio: false,
     tci_host: '', tci_port: 40001, tci_spots: false, poll_ms: 250, delay_ms: 0, offset_on: false, offset_hz: 0,
     digital_default: 'FT8', share_enabled: false, share_port: 4532, share_proto: 'rigctl', share_tci_port: 40001,
     ptt_hotkey_enabled: false, ptt_hotkey: '', ptt_hotkey_toggle: false,
   });
+  // Brand + connection, derived from the stored backend rather than held
+  // separately: two sources for one fact drift apart the first time something
+  // else writes the backend (loading a profile, an older settings file).
+  const catBrand = brandOfBackend(catCfg.backend, (catCfg as any).kenwood_link).brand;
+  const catLink = brandOfBackend(catCfg.backend, (catCfg as any).kenwood_link).link;
+  const applyCatBrand = (id: string) => {
+    const b = CAT_BRANDS.find((x) => x.id === id);
+    if (!b) return;
+    // Keep the connection when the new brand offers it, otherwise take its
+    // first — picking Flex from Kenwood-over-USB has to land on something.
+    const link = b.links.includes(catLink) ? catLink : b.links[0];
+    setCatCfg((s) => ({ ...s, backend: b.backend(link), kenwood_link: link } as any));
+  };
+  const applyCatLink = (link: string) => {
+    const b = CAT_BRANDS.find((x) => x.id === catBrand);
+    if (!b || !b.links.includes(link)) return;
+    setCatCfg((s) => ({ ...s, backend: b.backend(link), kenwood_link: link } as any));
+  };
+
   // While true, the next key press is captured as the PTT hotkey.
   const [capturingPtt, setCapturingPtt] = useState(false);
   const [rotors, setRotors] = useState<RotatorDevice[]>([]);
@@ -1544,7 +1622,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [ubTest, setUbTest] = useState<{ ok: boolean; msg: string } | null>(null);
 
   // Antenna Genius (4O3A) switch settings — TCP port is fixed at 9007.
-  const [antgenius, setAntgenius] = useState<{ enabled: boolean; host: string; password: string }>({ enabled: false, host: '', password: '' });
+  const [antgenius, setAntgenius] = useState<{ enabled: boolean; host: string; password: string; use_for_my_antenna?: boolean; ant1_port?: number }>({ enabled: false, host: '', password: '', use_for_my_antenna: false, ant1_port: 1 });
   const [tunergenius, setTunergenius] = useState<{ enabled: boolean; host: string; password: string }>({ enabled: false, host: '', password: '' });
   const [psuCfg, setPsuCfg] = useState<{ enabled: boolean; com_port: string; baud: number; address: number }>({ enabled: false, com_port: '', baud: 9600, address: 1 });
 
@@ -1861,10 +1939,23 @@ 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>('');
   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); }
   };
 
@@ -1933,7 +2024,6 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   // feed up or down — so the write has to go where those live.
   const [bandOpen, setBandOpen] = useState<any>({ enabled: false, bands: [], available: [] });
   // How a worked square is matched, and what counts as still wanted.
-  const [autoCall, setAutoCall] = useState<AutoCallSettings>(loadAutoCall);
   const [gridScope, setGridScope] = useState<any>({ scope: 'mix_digi', hunt: 'new', scopes: [] });
   useEffect(() => { GetGridScopeSettings().then((g) => setGridScope(g as any)).catch(() => {}); }, []);
   const saveGridScope = async (next: any) => {
@@ -1944,6 +2034,14 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
   const [chaseNew, setChaseNew] = useState(false);
   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) => {
@@ -1957,15 +2055,24 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
       try { setChaseNew(await GetChaseNew()); } catch { /* defaults stand */ }
       try { setLinkedAmps((await GetLinkedAmps()) ?? []); } catch { /* defaults stand */ }
       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 +2385,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 +2984,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 +3165,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 +3325,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 +3334,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 +3343,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 +3369,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')}
@@ -3822,6 +3994,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>
       </>
     );
@@ -4918,11 +5122,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>
@@ -4975,6 +5186,28 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 }} />
               <span className="text-xs text-muted-foreground">{t('clu.spotTtlHint')}</span>
             </div>
+            {/* The list size, beside the lifetime because between them they decide
+                the same thing: whichever runs out first removes the spot. */}
+            <div className="flex items-center gap-3 flex-wrap">
+              <span className="text-sm">{t('clu.spotMax')}</span>
+              <div className="inline-flex rounded-md border border-border overflow-hidden text-xs">
+                {[500, 1000, 2500, 5000].map((v) => (
+                  <button key={v} type="button"
+                    onClick={() => { setSpotMaxText(String(v)); SetSpotMax(v).catch(() => {}); }}
+                    className={cn('px-2.5 py-1.5 font-medium', Number(spotMaxText) === v ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')}>
+                    {v}
+                  </button>
+                ))}
+              </div>
+              <Input className="h-8 w-24" value={spotMaxText}
+                onChange={(e) => {
+                  const raw = e.target.value.replace(/[^0-9]/g, '');
+                  setSpotMaxText(raw);
+                  const n = parseInt(raw, 10);
+                  if (Number.isFinite(n) && n > 0) SetSpotMax(Math.min(10000, n)).catch(() => {});
+                }} />
+              <span className="text-xs text-muted-foreground">{t('clu.spotMaxHint')}</span>
+            </div>
           </div>
 
           <div className="border-t border-border/60 pt-3 space-y-2">
@@ -6520,6 +6753,12 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
             <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'}
@@ -7228,7 +7467,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>
@@ -7242,8 +7481,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', {
@@ -7256,7 +7496,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>
@@ -7270,7 +7522,19 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 <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>
@@ -7282,6 +7546,7 @@ export function SettingsModal({ onClose, onSaved, initialSection, onMainPaneChan
                 </tbody>
               </table>
             </div>
+            </>
           )}
         </div>
       </div>
@@ -7301,6 +7566,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
@@ -7315,7 +7581,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,
@@ -7483,6 +7758,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/WheelRange.tsx

@@ -0,0 +1,62 @@
+import { useEffect, useRef } from 'react';
+import { cn } from '@/lib/utils';
+
+// A range slider the mouse wheel can move.
+//
+// Dragging a 4-pixel-tall slider to change the power by five watts is a fussy
+// gesture; rolling the wheel over it is not, and it is what an operator reaches
+// for after using the Flex and Yaesu consoles, which have had it for a while.
+//
+// React's own onWheel is registered PASSIVE, so preventDefault() inside it is
+// ignored and the panel scrolls under the pointer while the value changes. The
+// listener therefore has to be attached natively with { passive: false }, and
+// the live values read through refs — the listener is installed once and would
+// otherwise capture the first render's value for ever.
+//
+// The Flex and Yaesu panels each grew their own copy of this before it was worth
+// sharing. They are left alone deliberately: they work, they are in daily use,
+// and their styling differs in small ways that a merge would have to guess at.
+export function WheelRange({ value, onChange, min = 0, max = 100, step = 1, disabled, accent = 'var(--primary)', className }: {
+  value: number; onChange: (v: number) => void;
+  min?: number; max?: number; step?: number; disabled?: boolean; accent?: string; className?: string;
+}) {
+  const v = Math.max(min, Math.min(max, value));
+  const pct = max > min ? ((v - min) / (max - min)) * 100 : 0;
+  const ref = useRef<HTMLInputElement>(null);
+  const valRef = useRef(v); valRef.current = v;
+  const cbRef = useRef(onChange); cbRef.current = onChange;
+  const disRef = useRef(disabled); disRef.current = disabled;
+  const stepRef = useRef(step); stepRef.current = step;
+  const minRef = useRef(min); minRef.current = min;
+  const maxRef = useRef(max); maxRef.current = max;
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onWheel = (e: WheelEvent) => {
+      if (disRef.current) return;
+      e.preventDefault();
+      const d = e.deltaY < 0 ? stepRef.current : -stepRef.current;
+      const nv = Math.max(minRef.current, Math.min(maxRef.current, valRef.current + d));
+      if (nv !== valRef.current) cbRef.current(nv);
+    };
+    el.addEventListener('wheel', onWheel, { passive: false });
+    return () => el.removeEventListener('wheel', onWheel);
+  }, []);
+
+  return (
+    <input
+      ref={ref}
+      type="range" min={min} max={max} step={step} value={v} disabled={disabled}
+      onChange={(e) => onChange(parseInt(e.target.value, 10))}
+      className={cn('flex-1 h-1.5 rounded-full appearance-none cursor-pointer disabled:opacity-30 disabled:cursor-default',
+        '[&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3.5 [&::-webkit-slider-thumb]:rounded-full',
+        '[&::-webkit-slider-thumb]:bg-card [&::-webkit-slider-thumb]:border-2 [&::-webkit-slider-thumb]:shadow-sm [&::-webkit-slider-thumb]:cursor-pointer',
+        className)}
+      style={{
+        background: `linear-gradient(to right, ${accent} ${pct}%, color-mix(in srgb, var(--foreground) 18%, transparent) ${pct}%)`,
+        borderColor: accent,
+      }}
+    />
+  );
+}

frontend/src/components/WinkeyerPanel.tsx

@@ -73,9 +73,17 @@ export function WinkeyerPanel({
 
   const connected = status.connected;
 
+  // Send-on-type only exists where the engine can key one character at a time:
+  // the WinKeyer and Flex CWX. The stored preference survives an engine change,
+  // though, and an Icom or Yaesu operator inherited a hidden switch that was on
+  // — the checkbox is not shown for them, so nothing keyed as they typed AND
+  // Enter sent nothing either, since it believes the text has already gone.
+  // Macros kept working, which is exactly how it looked from the outside.
+  const liveType = sendOnType && (source === 'winkeyer' || source === 'flex');
+
   function sendText() {
     const t = cwText.trim();
-    if (t && !sendOnType) onSend(t); // in send-on-type the text already went out
+    if (t && !liveType) onSend(t); // in send-on-type the text already went out
     setCwText('');
   }
 
@@ -83,7 +91,7 @@ export function WinkeyerPanel({
   // WinKeyer backspace for each deleted char (removes it from the buffer if it
   // hasn't been keyed yet). Only end-of-string edits are mirrored live.
   function onCwChange(v: string) {
-    if (sendOnType && connected) {
+    if (liveType && connected) {
       const old = cwText;
       if (v.length > old.length && v.startsWith(old)) {
         onSendRaw(v.slice(old.length));
@@ -200,13 +208,13 @@ export function WinkeyerPanel({
               value={cwText}
               onChange={(e) => onCwChange(e.target.value)}
               onKeyDown={(e) => { if (e.key === 'Enter') { e.preventDefault(); sendText(); } }}
-              placeholder={sendOnType ? t('wkp.phLive') : t('wkp.phEnter')}
+              placeholder={liveType ? t('wkp.phLive') : t('wkp.phEnter')}
               disabled={!connected}
               className="font-mono uppercase"
             />
           </div>
           <Button size="sm" className="h-8" onClick={sendText} disabled={!connected}>
-            <Send className="size-3.5" /> {sendOnType ? t('wkp.clear') : t('wkp.send')}
+            <Send className="size-3.5" /> {liveType ? t('wkp.clear') : t('wkp.send')}
           </Button>
           <Button variant="destructive" size="sm" className="h-8" onClick={onStop} disabled={!connected} title={t('wkp.abort')}>
             <Square className="size-3.5" /> {t('wkp.stop')}

frontend/src/components/YaesuPanel.tsx

@@ -18,7 +18,8 @@ type YaesuState = {
   s_meter: number; power_meter: number; swr_meter: number;
   rf_power: number; mic_gain: number; af_gain: number; rf_gain: number; squelch: number;
   agc?: string; preamp: number; att: number; antenna: number;
-  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; vox: boolean;
+  nb: boolean; nr: boolean; nr_level: number; narrow: boolean; narrow_supported?: boolean; vox: boolean;
+  max_power?: number;
   split_tx_hz?: number; key_speed?: number; break_in?: boolean; swr?: number; power_w?: number;
 };
 
@@ -445,7 +446,13 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <div className="flex items-center gap-2 flex-wrap">
           <Chip on={view.nb} onClick={() => push('nb', !view.nb, () => SetYaesuNB(!view.nb))} label="NB" />
           <Chip on={view.nr} onClick={() => push('nr', !view.nr, () => SetYaesuNR(!view.nr))} label="DNR" />
-          <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))} label="NAR" />
+          {/* NAR is the narrow IF filter. Shown only when the rig ANSWERED NA:
+              a button that does nothing when pressed reads as a fault in the
+              radio, which is how it was reported from an FTDX101. */}
+          {view.narrow_supported && (
+            <Chip on={view.narrow} onClick={() => push('narrow', !view.narrow, () => SetYaesuNarrow(!view.narrow))}
+              label="NAR" title={t('yaesu.narrowHint')} />
+          )}
         </div>
         <Row label="DNR">
           {/* 1-15 on the rig, shown as-is rather than rescaled to a percentage:
@@ -462,7 +469,7 @@ export function YaesuPanel({ onReportRST, onKeySpeed }: {
         <Row label="PWR">
           {/* Watts, not a percentage: the rig reports and takes watts, and a
               percentage would be a second unit to reconcile every time. */}
-          <Slider value={view.rf_power || 5} min={5} max={100} accent="var(--destructive)"
+          <Slider value={view.rf_power || 5} min={5} max={Math.max(100, view.max_power || 100)} accent="var(--destructive)"
             onChange={(v) => push('rf_power', v, () => SetYaesuPower(v))} />
           <span className="w-10 text-right text-xs font-mono tabular-nums text-muted-foreground">{view.rf_power}W</span>
         </Row>

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/lib/autocall.ts

@@ -72,13 +72,26 @@ export function loadAutoCall(): AutoCallSettings {
     const raw = localStorage.getItem(AC_KEY);
     if (!raw) return { ...defaultAutoCall };
     const v = JSON.parse(raw);
-    return {
+    const out: AutoCallSettings = {
       ...defaultAutoCall,
       ...v,
       criteria: { ...emptyCriteria, ...(v?.criteria ?? {}) },
       watchCriteria: { ...emptyCriteria, ...(v?.watchCriteria ?? {}) },
       watch: Array.isArray(v?.watch) ? v.watch : [],
     };
+    // DISARMED ON SIGHT, and written back disabled.
+    //
+    // The runtime guard in App.tsx stops this build from calling anyone, but it
+    // leaves "enabled": true sitting in storage, where any build without the
+    // guard — an older one an operator reinstalls, a machine that upgrades
+    // later — reads it and keys the transmitter for a feature with no switch
+    // left to turn off. A withdrawn feature that keys a radio has to be
+    // disarmed where it is REMEMBERED, not only where it runs.
+    if (out.enabled) {
+      out.enabled = false;
+      try { localStorage.setItem(AC_KEY, JSON.stringify(out)); } catch { /* private mode: the guard still holds */ }
+    }
+    return out;
   } catch { return { ...defaultAutoCall }; }
 }
 

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.9';
+export const APP_VERSION = '0.26.15';
 
 // Author / credits, shown in Help -> About.
 export const APP_AUTHOR = 'F4BPO';

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

@@ -119,6 +119,8 @@ export function CheckForUpdate():Promise<main.UpdateInfo>;
 
 export function CheckHamlogKey(arg1:string):Promise<string>;
 
+export function ClearKenwoodRIT():Promise<void>;
+
 export function ClearLookupCache():Promise<void>;
 
 export function CloseAutostartPrograms():Promise<void>;
@@ -233,6 +235,8 @@ export function ExportCabrilloFiltered(arg1:string,arg2:qso.QueryFilter):Promise
 
 export function ExportCabrilloSelected(arg1:string,arg2:Array<number>):Promise<main.CabrilloResult>;
 
+export function ExportHamlogUnmatched(arg1:string):Promise<number>;
+
 export function FilterFields():Promise<Array<string>>;
 
 export function FindDuplicates(arg1:number):Promise<Array<main.DuplicateGroup>>;
@@ -469,6 +473,8 @@ export function GetFlexBandAntennas():Promise<Record<string, main.FlexBandAnt>>;
 
 export function GetFlexBandPower():Promise<Record<string, main.FlexBandPower>>;
 
+export function GetFlexRSTChase():Promise<main.FlexRSTChase>;
+
 export function GetFlexState():Promise<cat.FlexTXState>;
 
 export function GetFlexZoom():Promise<main.FlexZoomSettings>;
@@ -483,6 +489,8 @@ export function GetGridScopeSettings():Promise<main.GridScopeSettings>;
 
 export function GetIcomState():Promise<cat.IcomTXState>;
 
+export function GetKenwoodState():Promise<cat.KenwoodTXState>;
+
 export function GetLinkedAmps():Promise<Array<string>>;
 
 export function GetListsSettings():Promise<main.ListsSettings>;
@@ -555,6 +563,8 @@ export function GetSolarData():Promise<solar.Data>;
 
 export function GetSpotColors():Promise<main.SpotColors>;
 
+export function GetSpotMax():Promise<number>;
+
 export function GetSpotTTLMinutes():Promise<number>;
 
 export function GetStartupStatus():Promise<main.StartupStatus>;
@@ -793,6 +803,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>;
@@ -895,6 +907,8 @@ export function RecomputeAwardRefsForCode(arg1:string):Promise<number>;
 
 export function RefreshCtyDat():Promise<main.CtyDatInfo>;
 
+export function RefreshKenwood():Promise<void>;
+
 export function RefreshSolar():Promise<void>;
 
 export function RefreshYaesuPanel():Promise<void>;
@@ -989,6 +1003,8 @@ export function SaveFlexBandAntennas(arg1:Record<string, main.FlexBandAnt>):Prom
 
 export function SaveFlexBandPower(arg1:Record<string, main.FlexBandPower>):Promise<void>;
 
+export function SaveFlexRSTChase(arg1:main.FlexRSTChase):Promise<void>;
+
 export function SaveFlexZoom(arg1:main.FlexZoomSettings):Promise<void>;
 
 export function SaveFolderSync(arg1:main.FolderSyncConfig):Promise<void>;
@@ -1091,8 +1107,40 @@ export function SetCompactMode(arg1:boolean):Promise<void>;
 
 export function SetDVKLabel(arg1:number,arg2:string):Promise<void>;
 
+export function SetFlexRSTChaseEnabled(arg1:boolean):Promise<void>;
+
+export function SetKenwoodAFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodAGC(arg1:string):Promise<void>;
+
+export function SetKenwoodAntenna(arg1:number):Promise<void>;
+
+export function SetKenwoodAtt(arg1:boolean):Promise<void>;
+
+export function SetKenwoodFilter(arg1:number):Promise<void>;
+
 export function SetKenwoodKeySpeed(arg1:number):Promise<void>;
 
+export function SetKenwoodMicGain(arg1:number):Promise<void>;
+
+export function SetKenwoodNB(arg1:boolean):Promise<void>;
+
+export function SetKenwoodNR(arg1:boolean):Promise<void>;
+
+export function SetKenwoodPower(arg1:number):Promise<void>;
+
+export function SetKenwoodPreamp(arg1:boolean):Promise<void>;
+
+export function SetKenwoodRFGain(arg1:number):Promise<void>;
+
+export function SetKenwoodRIT(arg1:boolean):Promise<void>;
+
+export function SetKenwoodSquelch(arg1:number):Promise<void>;
+
+export function SetKenwoodTX(arg1:boolean):Promise<void>;
+
+export function SetKenwoodXIT(arg1:boolean):Promise<void>;
+
 export function SetLinkedAmps(arg1:Array<string>):Promise<void>;
 
 export function SetMotorFollow(arg1:boolean,arg2:number,arg3:string):Promise<void>;
@@ -1105,6 +1153,8 @@ export function SetPassphrase(arg1:string):Promise<void>;
 
 export function SetScpEnabled(arg1:boolean):Promise<void>;
 
+export function SetSpotMax(arg1:number):Promise<void>;
+
 export function SetSpotTTLMinutes(arg1:number):Promise<void>;
 
 export function SetTelemetryEnabled(arg1:boolean):Promise<void>;
@@ -1199,6 +1249,10 @@ export function TestUltrabeam(arg1:main.UltrabeamSettings):Promise<void>;
 
 export function TestWebPublishFTP(arg1:webpub.Config):Promise<string>;
 
+export function ToggleKenwoodATU():Promise<void>;
+
+export function TuneKenwoodATU():Promise<void>;
+
 export function TuneYaesuATU():Promise<void>;
 
 export function TunerGeniusActivate(arg1:number):Promise<void>;

frontend/wailsjs/go/main/App.js

@@ -178,6 +178,10 @@ export function CheckHamlogKey(arg1) {
   return window['go']['main']['App']['CheckHamlogKey'](arg1);
 }
 
+export function ClearKenwoodRIT() {
+  return window['go']['main']['App']['ClearKenwoodRIT']();
+}
+
 export function ClearLookupCache() {
   return window['go']['main']['App']['ClearLookupCache']();
 }
@@ -406,6 +410,10 @@ export function ExportCabrilloSelected(arg1, arg2) {
   return window['go']['main']['App']['ExportCabrilloSelected'](arg1, arg2);
 }
 
+export function ExportHamlogUnmatched(arg1) {
+  return window['go']['main']['App']['ExportHamlogUnmatched'](arg1);
+}
+
 export function FilterFields() {
   return window['go']['main']['App']['FilterFields']();
 }
@@ -878,6 +886,10 @@ export function GetFlexBandPower() {
   return window['go']['main']['App']['GetFlexBandPower']();
 }
 
+export function GetFlexRSTChase() {
+  return window['go']['main']['App']['GetFlexRSTChase']();
+}
+
 export function GetFlexState() {
   return window['go']['main']['App']['GetFlexState']();
 }
@@ -906,6 +918,10 @@ export function GetIcomState() {
   return window['go']['main']['App']['GetIcomState']();
 }
 
+export function GetKenwoodState() {
+  return window['go']['main']['App']['GetKenwoodState']();
+}
+
 export function GetLinkedAmps() {
   return window['go']['main']['App']['GetLinkedAmps']();
 }
@@ -1050,6 +1066,10 @@ export function GetSpotColors() {
   return window['go']['main']['App']['GetSpotColors']();
 }
 
+export function GetSpotMax() {
+  return window['go']['main']['App']['GetSpotMax']();
+}
+
 export function GetSpotTTLMinutes() {
   return window['go']['main']['App']['GetSpotTTLMinutes']();
 }
@@ -1526,6 +1546,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']();
 }
@@ -1730,6 +1754,10 @@ export function RefreshCtyDat() {
   return window['go']['main']['App']['RefreshCtyDat']();
 }
 
+export function RefreshKenwood() {
+  return window['go']['main']['App']['RefreshKenwood']();
+}
+
 export function RefreshSolar() {
   return window['go']['main']['App']['RefreshSolar']();
 }
@@ -1918,6 +1946,10 @@ export function SaveFlexBandPower(arg1) {
   return window['go']['main']['App']['SaveFlexBandPower'](arg1);
 }
 
+export function SaveFlexRSTChase(arg1) {
+  return window['go']['main']['App']['SaveFlexRSTChase'](arg1);
+}
+
 export function SaveFlexZoom(arg1) {
   return window['go']['main']['App']['SaveFlexZoom'](arg1);
 }
@@ -2122,10 +2154,74 @@ export function SetDVKLabel(arg1, arg2) {
   return window['go']['main']['App']['SetDVKLabel'](arg1, arg2);
 }
 
+export function SetFlexRSTChaseEnabled(arg1) {
+  return window['go']['main']['App']['SetFlexRSTChaseEnabled'](arg1);
+}
+
+export function SetKenwoodAFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodAFGain'](arg1);
+}
+
+export function SetKenwoodAGC(arg1) {
+  return window['go']['main']['App']['SetKenwoodAGC'](arg1);
+}
+
+export function SetKenwoodAntenna(arg1) {
+  return window['go']['main']['App']['SetKenwoodAntenna'](arg1);
+}
+
+export function SetKenwoodAtt(arg1) {
+  return window['go']['main']['App']['SetKenwoodAtt'](arg1);
+}
+
+export function SetKenwoodFilter(arg1) {
+  return window['go']['main']['App']['SetKenwoodFilter'](arg1);
+}
+
 export function SetKenwoodKeySpeed(arg1) {
   return window['go']['main']['App']['SetKenwoodKeySpeed'](arg1);
 }
 
+export function SetKenwoodMicGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodMicGain'](arg1);
+}
+
+export function SetKenwoodNB(arg1) {
+  return window['go']['main']['App']['SetKenwoodNB'](arg1);
+}
+
+export function SetKenwoodNR(arg1) {
+  return window['go']['main']['App']['SetKenwoodNR'](arg1);
+}
+
+export function SetKenwoodPower(arg1) {
+  return window['go']['main']['App']['SetKenwoodPower'](arg1);
+}
+
+export function SetKenwoodPreamp(arg1) {
+  return window['go']['main']['App']['SetKenwoodPreamp'](arg1);
+}
+
+export function SetKenwoodRFGain(arg1) {
+  return window['go']['main']['App']['SetKenwoodRFGain'](arg1);
+}
+
+export function SetKenwoodRIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodRIT'](arg1);
+}
+
+export function SetKenwoodSquelch(arg1) {
+  return window['go']['main']['App']['SetKenwoodSquelch'](arg1);
+}
+
+export function SetKenwoodTX(arg1) {
+  return window['go']['main']['App']['SetKenwoodTX'](arg1);
+}
+
+export function SetKenwoodXIT(arg1) {
+  return window['go']['main']['App']['SetKenwoodXIT'](arg1);
+}
+
 export function SetLinkedAmps(arg1) {
   return window['go']['main']['App']['SetLinkedAmps'](arg1);
 }
@@ -2150,6 +2246,10 @@ export function SetScpEnabled(arg1) {
   return window['go']['main']['App']['SetScpEnabled'](arg1);
 }
 
+export function SetSpotMax(arg1) {
+  return window['go']['main']['App']['SetSpotMax'](arg1);
+}
+
 export function SetSpotTTLMinutes(arg1) {
   return window['go']['main']['App']['SetSpotTTLMinutes'](arg1);
 }
@@ -2338,6 +2438,14 @@ export function TestWebPublishFTP(arg1) {
   return window['go']['main']['App']['TestWebPublishFTP'](arg1);
 }
 
+export function ToggleKenwoodATU() {
+  return window['go']['main']['App']['ToggleKenwoodATU']();
+}
+
+export function TuneKenwoodATU() {
+  return window['go']['main']['App']['TuneKenwoodATU']();
+}
+
 export function TuneYaesuATU() {
   return window['go']['main']['App']['TuneYaesuATU']();
 }

frontend/wailsjs/go/models.ts

@@ -1067,6 +1067,74 @@ export namespace cat {
 	        this.anti_vox = source["anti_vox"];
 	    }
 	}
+	export class KenwoodTXState {
+	    available: boolean;
+	    model?: string;
+	    elecraft: boolean;
+	    mode?: string;
+	    transmitting: boolean;
+	    split: boolean;
+	    split_tx_hz: number;
+	    s_meter: number;
+	    s_meter_raw: number;
+	    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;
+	    rit_offset: number;
+	    key_speed: number;
+	    meters_provisional: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new KenwoodTXState(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.available = source["available"];
+	        this.model = source["model"];
+	        this.elecraft = source["elecraft"];
+	        this.mode = source["mode"];
+	        this.transmitting = source["transmitting"];
+	        this.split = source["split"];
+	        this.split_tx_hz = source["split_tx_hz"];
+	        this.s_meter = source["s_meter"];
+	        this.s_meter_raw = source["s_meter_raw"];
+	        this.power_meter = source["power_meter"];
+	        this.swr = source["swr"];
+	        this.swr_raw = source["swr_raw"];
+	        this.rf_power = source["rf_power"];
+	        this.af_gain = source["af_gain"];
+	        this.rf_gain = source["rf_gain"];
+	        this.mic_gain = source["mic_gain"];
+	        this.squelch = source["squelch"];
+	        this.preamp = source["preamp"];
+	        this.att = source["att"];
+	        this.nb = source["nb"];
+	        this.nr = source["nr"];
+	        this.agc = source["agc"];
+	        this.filter_hz = source["filter_hz"];
+	        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"];
+	    }
+	}
 	export class RigState {
 	    enabled: boolean;
 	    connected: boolean;
@@ -1154,6 +1222,8 @@ export namespace cat {
 	    power_meter: number;
 	    swr_meter: number;
 	    rf_power: number;
+	    max_power: number;
+	    narrow_supported: boolean;
 	    mic_gain: number;
 	    af_gain: number;
 	    rf_gain: number;
@@ -1189,6 +1259,8 @@ export namespace cat {
 	        this.power_meter = source["power_meter"];
 	        this.swr_meter = source["swr_meter"];
 	        this.rf_power = source["rf_power"];
+	        this.max_power = source["max_power"];
+	        this.narrow_supported = source["narrow_supported"];
 	        this.mic_gain = source["mic_gain"];
 	        this.af_gain = source["af_gain"];
 	        this.rf_gain = source["rf_gain"];
@@ -1666,6 +1738,8 @@ export namespace main {
 	    enabled: boolean;
 	    host: string;
 	    password: string;
+	    use_for_my_antenna: boolean;
+	    ant1_port: number;
 	
 	    static createFrom(source: any = {}) {
 	        return new AntGeniusSettings(source);
@@ -1676,6 +1750,8 @@ export namespace main {
 	        this.enabled = source["enabled"];
 	        this.host = source["host"];
 	        this.password = source["password"];
+	        this.use_for_my_antenna = source["use_for_my_antenna"];
+	        this.ant1_port = source["ant1_port"];
 	    }
 	}
 	export class AudioSettings {
@@ -2076,6 +2152,7 @@ export namespace main {
 	    yaesu_baud: number;
 	    kenwood_host: string;
 	    kenwood_port: string;
+	    kenwood_link: string;
 	    kenwood_baud: number;
 	    kenwood_data_mode: string;
 	    yaesu_low_lines: boolean;
@@ -2127,6 +2204,7 @@ export namespace main {
 	        this.yaesu_baud = source["yaesu_baud"];
 	        this.kenwood_host = source["kenwood_host"];
 	        this.kenwood_port = source["kenwood_port"];
+	        this.kenwood_link = source["kenwood_link"];
 	        this.kenwood_baud = source["kenwood_baud"];
 	        this.kenwood_data_mode = source["kenwood_data_mode"];
 	        this.yaesu_low_lines = source["yaesu_low_lines"];
@@ -2537,6 +2615,24 @@ export namespace main {
 	        this.body = source["body"];
 	    }
 	}
+	export class FlexRSTChase {
+	    enabled: boolean;
+	    markers: string;
+	    offset_hz: number;
+	    split_only: boolean;
+	
+	    static createFrom(source: any = {}) {
+	        return new FlexRSTChase(source);
+	    }
+	
+	    constructor(source: any = {}) {
+	        if ('string' === typeof source) source = JSON.parse(source);
+	        this.enabled = source["enabled"];
+	        this.markers = source["markers"];
+	        this.offset_hz = source["offset_hz"];
+	        this.split_only = source["split_only"];
+	    }
+	}
 	export class FlexZoomSettings {
 	    enabled: boolean;
 	    cw_khz: number;
@@ -2743,6 +2839,7 @@ export namespace main {
 	    rst_phone: string[];
 	    rst_cw: string[];
 	    rst_digital: string[];
+	    satellites: string[];
 	
 	    static createFrom(source: any = {}) {
 	        return new ListsSettings(source);
@@ -2755,6 +2852,7 @@ export namespace main {
 	        this.rst_phone = source["rst_phone"];
 	        this.rst_cw = source["rst_cw"];
 	        this.rst_digital = source["rst_digital"];
+	        this.satellites = source["satellites"];
 	    }
 	
 		convertValues(a: any, classs: any, asMap: boolean = false): any {

hamlogcfm.go

@@ -34,6 +34,11 @@ import (
 	"hamlog/internal/qso"
 )
 
+// hamlogUnmatchedMax bounds what is kept for export. A whole log's worth of
+// unmatched records means the file belongs to another station, not that the
+// operator wants 50 000 of them written back out.
+const hamlogUnmatchedMax = 20000
+
 // HamlogCfmResult is what the import did.
 type HamlogCfmResult struct {
 	Total     int `json:"total"`     // records read from the file
@@ -42,7 +47,9 @@ type HamlogCfmResult struct {
 	ByClass   int `json:"by_class"`  // matched on mode CLASS rather than exact mode
 	Unmatched int `json:"unmatched"` // confirmations with no local QSO
 	// Samples names a few unmatched contacts, so "12 unmatched" can be looked
-	// into rather than merely worried about.
+	// into rather than merely worried about. The full list is kept for export —
+	// see ExportHamlogUnmatched — because 395 of them is not a sample-sized
+	// problem: it is a list to work through.
 	Samples []string `json:"samples"`
 }
 
@@ -86,6 +93,14 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 	}
 	emit("Reading " + path + "…")
 
+	// What already counts towards an award, so each confirmation can be flagged
+	// NEW. LoTW and paper QSL are the two award-valid sources; a HAMLOG
+	// confirmation is "new" when it lands on a slot neither of them holds — which
+	// is the only sense in which it changes anything.
+	sets, _ := a.qso.ConfirmedSlots(ctx, []string{"lotw_rcvd", "qsl_rcvd"})
+	var items []ConfirmationItem
+	var unmatched []qso.QSO
+
 	perr := adif.Parse(f, func(rec adif.Record) error {
 		q, ok := adif.RecordToQSO(rec)
 		if !ok {
@@ -116,6 +131,9 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 				res.Samples = append(res.Samples, fmt.Sprintf("%s · %s · %s · %s",
 					q.Callsign, q.QSODate.UTC().Format("2006-01-02 15:04Z"), q.Band, q.Mode))
 			}
+			if len(unmatched) < hamlogUnmatchedMax {
+				unmatched = append(unmatched, q)
+			}
 			return nil
 		}
 		date := hamlogCfmDate(rec)
@@ -128,12 +146,45 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 		// from their website would otherwise read "never sent, yet confirmed".
 		_ = a.qso.SetExtra(ctx, id, hamlogSentKey, "Y")
 		res.Matched++
+
+		// Feed the Results view, the same rows the LoTW download produces: an
+		// import that only prints counts leaves the operator with no way to see
+		// WHICH contacts were confirmed, which is the reason they ran it.
+		a.enrichContactedFromCty(&q) // country/dxcc, for the entity flags
+		it := ConfirmationItem{
+			Callsign: q.Callsign,
+			QSODate:  q.QSODate.UTC().Format(time.RFC3339),
+			Band:     q.Band,
+			Mode:     q.Mode,
+			Country:  q.Country,
+		}
+		if q.DXCC != nil && *q.DXCC != 0 {
+			n := *q.DXCC
+			it.NewDXCC = !sets.DXCC[n]
+			it.NewBand = !sets.Band[qso.BandKey(n, q.Band)]
+			it.NewMode = !sets.Mode[qso.ModeClassKey(n, q.Mode)]
+			it.NewSlot = !sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)]
+			// Fold it in, so a repeat inside the same file isn't flagged twice.
+			sets.DXCC[n] = true
+			sets.Band[qso.BandKey(n, q.Band)] = true
+			sets.Mode[qso.ModeClassKey(n, q.Mode)] = true
+			sets.Slot[qso.SlotClassKey(n, q.Band, q.Mode)] = true
+		}
+		items = append(items, it)
 		return nil
 	})
 	if perr != nil {
 		return res, perr
 	}
 	a.invalidateAwardStats() // confirmations move award counts
+	// Kept for ExportHamlogUnmatched. Held rather than written now: the operator
+	// decides whether a list of 395 is worth a file.
+	a.hamlogUnmatchedMu.Lock()
+	a.hamlogUnmatched = unmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if a.ctx != nil {
+		wruntime.EventsEmit(a.ctx, "qslmgr:confirmations", items)
+	}
 	applog.Printf("hamlog cfm import: %d records, %d confirmed, %d matched (%d by mode class), %d unmatched",
 		res.Total, res.Confirmed, res.Matched, res.ByClass, res.Unmatched)
 	emit(fmt.Sprintf("%d records read, %d confirmed by HAMLOG.online, %d matched in the log (%d by mode class), %d unmatched",
@@ -141,12 +192,47 @@ func (a *App) ImportHamlogConfirmations(path string) (HamlogCfmResult, error) {
 	for _, s := range res.Samples {
 		emit("  unmatched: " + s)
 	}
+	if res.Unmatched > len(res.Samples) {
+		emit(fmt.Sprintf("  …and %d more — use \"Export unmatched (ADIF)…\" to get the whole list.",
+			res.Unmatched-len(res.Samples)))
+	}
 	if a.ctx != nil {
 		wruntime.EventsEmit(a.ctx, "qslmgr:done", map[string]any{"uploaded": res.Matched, "total": res.Confirmed})
 	}
 	return res, nil
 }
 
+// ExportHamlogUnmatched writes the confirmations the last import could not
+// place onto a QSO.
+//
+// They are the interesting half of the result: each one is a contact HAMLOG
+// believes it holds and this log does not agree about — a minute of drift, a
+// portable call, a band written differently, or a QSO genuinely missing. A
+// count cannot be worked through; a file can be opened, sorted and compared.
+//
+// Written as ADIF because that is what every other tool reads, and because it
+// can be handed straight back to an import once the discrepancies are settled.
+func (a *App) ExportHamlogUnmatched(path string) (int, error) {
+	a.hamlogUnmatchedMu.Lock()
+	rows := a.hamlogUnmatched
+	a.hamlogUnmatchedMu.Unlock()
+	if len(rows) == 0 {
+		return 0, fmt.Errorf("nothing to export: the last import left no unmatched confirmations")
+	}
+	if strings.TrimSpace(path) == "" {
+		return 0, fmt.Errorf("empty path")
+	}
+	recs := make([]string, 0, len(rows))
+	for i := range rows {
+		recs = append(recs, adif.FullRecordADIF(rows[i]))
+	}
+	if err := os.WriteFile(path, []byte(adif.BatchRecordsADIF(recs)), 0o644); err != nil {
+		return 0, err
+	}
+	applog.Printf("hamlog cfm import: exported %d unmatched confirmation(s) to %s", len(rows), path)
+	return len(rows), nil
+}
+
 // hamlogQSLDateKey stamps WHEN the confirmation was read back. Their export
 // carries no confirmation date of its own, so this is the import date — which
 // is honest about what it knows, unlike borrowing the QSO date.

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/award/award.go

@@ -344,7 +344,7 @@ func Migrate(defs []Def) ([]Def, bool) {
 func Fields() []string {
 	return []string{
 		"dxcc", "cqz", "ituz", "prefix", "callsign",
-		"state", "us_county", "cont", "country", "grid", "grid4",
+		"state", "county", "us_county", "cont", "country", "grid", "grid4",
 		"iota", "sota_ref", "pota_ref", "wwff",
 		"name", "qth", "address", "comment", "note",
 	}
@@ -1373,6 +1373,13 @@ func fieldRaw(field string, q *qso.QSO) string {
 		return q.Callsign
 	case "state":
 		return q.State
+	case "county":
+		// CNTY as it stands, with nothing prepended. us_county below answers a
+		// different question — it keys the county to its state, because two US
+		// states each have a Jefferson County. Outside the United States that
+		// prefixing is wrong: an RDA district (RO-19) and a Japanese city code
+		// are already unique, and a state is not what qualifies them.
+		return q.County
 	case "us_county":
 		return USCountyKey(q.State, q.County)
 	case "cont":

internal/award/fieldvalue_county_test.go

@@ -0,0 +1,29 @@
+package award
+
+import (
+	"testing"
+
+	"hamlog/internal/qso"
+)
+
+// A district lives in CNTY as-is; the US award field keys it to the state
+// because county names repeat across states. Confusing the two silently breaks
+// whichever award is not American.
+func TestCountyFieldIsRawWhileUSCountyIsKeyed(t *testing.T) {
+	q := &qso.QSO{State: "TX", County: "RO-19"}
+	if got := fieldRaw("county", q); got != "RO-19" {
+		t.Fatalf("county = %q, want RO-19", got)
+	}
+	if got := fieldRaw("us_county", q); got == "RO-19" {
+		t.Fatalf("us_county should key the county to its state, got %q", got)
+	}
+	var found bool
+	for _, f := range Fields() {
+		if f == "county" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("county missing from the award field list")
+	}
+}

internal/cat/cat.go

@@ -487,6 +487,8 @@ type FlexController interface {
 	// keeps freqMHz inside it, re-centring when it must. See Flex.ZoomPan.
 	ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error
 	SetTXSlice(int) error // make slice idx the transmitter (tx=1)
+	// SetTXSliceFrequency moves the TRANSMIT slice only — split pile-up chasing.
+	SetTXSliceFrequency(int64) error
 	SetSplit(bool) error
 	SetNB(bool) error
 	SetNBLevel(int) error
@@ -988,6 +990,30 @@ type KenwoodController interface {
 	SetKeySpeed(int) error
 }
 
+// KenwoodState returns the K3/K4 panel snapshot, or (zero, false) when the
+// active backend is not a Kenwood-dialect rig.
+func (m *Manager) KenwoodState() (KenwoodTXState, bool) {
+	m.mu.RLock()
+	b := m.backend
+	m.mu.RUnlock()
+	if kc, ok := b.(KenwoodPanelController); ok {
+		return kc.KenwoodState(), true
+	}
+	return KenwoodTXState{}, false
+}
+
+// KenwoodPanelDo dispatches a K3/K4 panel control onto the CAT goroutine, so a
+// panel click and the poll loop never share the serial port at the same instant.
+func (m *Manager) KenwoodPanelDo(fn func(KenwoodPanelController) error) error {
+	return m.exec(func(b Backend) error {
+		kc, ok := b.(KenwoodPanelController)
+		if !ok {
+			return fmt.Errorf("active CAT backend is not a Kenwood/Elecraft")
+		}
+		return fn(kc)
+	})
+}
+
 // KenwoodDo dispatches a Kenwood control onto the CAT goroutine.
 func (m *Manager) KenwoodDo(fn func(KenwoodController) error) error {
 	return m.exec(func(b Backend) error {

internal/cat/flex.go

@@ -60,6 +60,9 @@ type Flex struct {
 	txRawLogged    bool         // log the first raw transmit status once (field-name audit)
 
 	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
 	spotIdx         map[int]bool   // panadapter spot indices currently known to the radio
 	pendingSpot     map[int]string // seq → callsign, awaiting the spot index in the R response
 	pendingSpotMode map[int]string // seq → ADIF mode, paired with pendingSpot
@@ -92,6 +95,16 @@ type Flex struct {
 	// the spot, since the radio's own notification carries only an index. The host
 	// wires this to fill the entry form and to size the panadapter. Set before Connect.
 	OnSpotClick func(callsign string, freqHz int64, mode string)
+
+	// OnForeignSpot is called for every spot posted to the radio by a program
+	// OTHER than OpsLog, with the spot's callsign field and its frequency.
+	//
+	// A CW skimmer posts what it decodes, so the marker a DX operator's report
+	// leaves on the panadapter arrives here — that is what the split chaser acts
+	// on. Deliberately raw: this package reports what the radio said and does not
+	// decide what a marker looks like, because the marker text is configured in
+	// the skimmer, by the operator, and only they know what they chose.
+	OnForeignSpot func(callsign string, freqHz int64)
 }
 
 // panView is one panadapter's visible window, in MHz.
@@ -278,11 +291,18 @@ func (f *Flex) Connect() error {
 	f.send("sub pan all")       // panadapter centre/bandwidth, so a zoom knows where the display already is
 	f.send("sub client all")    // learn the GUI client (SmartSDR) so we can bind to it (below)
 	f.startMeters(conn)         // open the UDP VITA-49 stream for live meters
+	// Always subscribed, even when OpsLog draws no spots of its own: the feed is
+	// read-only and it is how the spots posted by OTHER programs arrive — a CW
+	// skimmer's decoded reports, which the split chaser acts on. Tying the
+	// subscription to our own overlay meant a station using SDC and no OpsLog
+	// spots heard nothing at all.
+	f.send("sub spot all")
 	if f.spotsEnabled {
-		// Subscribe so the radio pushes existing spots (we learn their indices),
+		// Wipe the panadapter so stale spots from a previous session or another
-		// then wipe the panadapter so stale spots from a previous session or
+		// logger are cleared before we start adding our own. Only when the
-		// another logger are cleared before we start adding our own.
+		// overlay is ours to manage: "spot clear" removes EVERY spot on the
-		f.send("sub spot all")
+		// radio, a skimmer's included, and taking those away from an operator
+		// who never asked us to draw anything would be pure vandalism.
 		go f.clearSpotsOnConnect(conn)
 	}
 	return nil
@@ -883,6 +903,10 @@ func (f *Flex) handleStatus(payload string) {
 					f.spotIdx[idx] = true
 				}
 				f.mu.Unlock()
+				if !removed {
+					f.probeForeignSpot(payload)
+					f.reportForeignSpot(payload)
+				}
 			}
 			debugLog.Printf("Flex: status %s", payload)
 		}
@@ -1377,6 +1401,105 @@ func (f *Flex) ZoomPan(bandwidthMHz, freqMHz float64, centre bool) error {
 	return nil
 }
 
+// foreignSpotProbeMax bounds the probe below. Enough lines to see what another
+// program writes into a spot, few enough that a running skimmer — which posts
+// hundreds an hour — cannot fill the log file with them.
+const foreignSpotProbeMax = 60
+
+// probeForeignSpot records, verbatim, the spots this radio receives from
+// programs OTHER than OpsLog.
+//
+// A CW skimmer (SDC, for one) posts what it decodes as panadapter spots, the
+// exchange included: chasing a split pileup means finding the "5NN" the DX just
+// sent and moving the transmit slice there. Acting on that requires knowing
+// exactly what the spot looks like — which field carries the text, whether the
+// report is the callsign or the comment, what source names the skimmer — and no
+// amount of reasoning substitutes for reading real lines off a real radio.
+//
+// So this logs and does nothing else. It is deliberately not a feature.
+func (f *Flex) probeForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	f.mu.Lock()
+	if f.foreignSpotSeen >= foreignSpotProbeMax {
+		f.mu.Unlock()
+		return
+	}
+	f.foreignSpotSeen++
+	n := f.foreignSpotSeen
+	f.mu.Unlock()
+	debugLog.Printf("flex: foreign spot %d/%d: %s", n, foreignSpotProbeMax, payload)
+	if n == foreignSpotProbeMax {
+		debugLog.Printf("flex: that is enough foreign spots to go on — no more will be logged this session")
+	}
+}
+
+// reportForeignSpot hands another program's spot to OnForeignSpot.
+//
+// Off the reader goroutine, like OnSpotClick: the handler tunes the radio, and
+// a command sent from inside the reader would deadlock against the socket it is
+// reading.
+func (f *Flex) reportForeignSpot(payload string) {
+	if strings.Contains(payload, "source=OpsLog") {
+		return
+	}
+	handler := f.OnForeignSpot
+	if handler == nil {
+		return
+	}
+	var call string
+	var hz int64
+	for _, kv := range strings.Fields(payload) {
+		eq := strings.IndexByte(kv, '=')
+		if eq <= 0 {
+			continue
+		}
+		switch kv[:eq] {
+		case "callsign":
+			call = kv[eq+1:]
+		case "rx_freq":
+			if mhz, err := strconv.ParseFloat(kv[eq+1:], 64); err == nil {
+				hz = int64(math.Round(mhz * 1e6))
+			}
+		}
+	}
+	if call == "" || hz <= 0 {
+		return
+	}
+	go handler(call, hz)
+}
+
+// SetTXSliceFrequency tunes the TRANSMIT slice, leaving the receive slice where
+// it is. That distinction is the whole point in split: the operator listens to
+// the DX on one slice and moves the other around the pile-up.
+func (f *Flex) SetTXSliceFrequency(hz int64) error {
+	if hz <= 0 {
+		return fmt.Errorf("flex: invalid frequency")
+	}
+	f.mu.Lock()
+	idx := -1
+	for i, s := range f.slices {
+		if s != nil && s.inUse && s.tx {
+			idx = i
+			break
+		}
+	}
+	if idx >= 0 && f.slices[idx] != nil {
+		f.slices[idx].freqHz = hz // optimistic, like SetFrequency
+	}
+	connected := f.conn != nil
+	f.mu.Unlock()
+	if idx < 0 {
+		return fmt.Errorf("flex: no transmit slice")
+	}
+	if !connected {
+		return fmt.Errorf("flex: not connected")
+	}
+	f.send(fmt.Sprintf("slice t %d %.6f", idx, float64(hz)/1e6))
+	return nil
+}
+
 // SendSpot renders a cluster spot on the panadapter via "spot add". Spots carry
 // a lifetime so the radio expires them on its own (the API has no "spot clear").
 // Per the SmartSDR API, spaces inside a field value are encoded as 0x7F.

internal/cat/kenwood.go

@@ -91,6 +91,23 @@ type Kenwood struct {
 	keyWPM         int // CW keyer speed, for pacing the KY buffer (see kenwood_cw.go)
 	// Commands this rig answered "?;" to — asked once, then never again.
 	unsupported map[string]bool
+	// noLatch suspends that memory while a refusal is expected to be about
+	// timing rather than capability (see ask).
+	noLatch bool
+
+	// Panel state — the K3/K4 control panel, see kenwood_panel.go. Read on the
+	// same serialised link as everything else, on a slow beat for the settings
+	// and every poll for the meters.
+	panel        KenwoodTXState
+	// The icon/status word, for working out which bit says "ATU in line" — see
+	// probeIcons. Kept so only CHANGES are logged.
+	lastIcons  string
+	iconProbes int
+	panelCycle   int
+	panelLoaded  bool
+	metersLogged int
+	powerPeak    meterPeak
+	swrPeak      meterPeak
 
 	// rx holds bytes read but not yet consumed, ACROSS calls to ask.
 	//
@@ -256,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 != "" {
@@ -299,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;")
@@ -422,6 +457,15 @@ func (k *Kenwood) ReadState() (RigState, error) {
 		k.curRXFreq = s.RxFreqHz
 	}
 	k.lastState = s // cache for the transmit window, where we can't poll
+	// 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.
+	// 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
 }
 
@@ -649,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

@@ -0,0 +1,652 @@
+package cat
+
+// Elecraft K3/K4 control panel — power, volume, S-meter, SWR, MOX and ATU tune.
+//
+// Built on the Kenwood-dialect backend, because a K3 speaks it: plain ASCII,
+// every command terminated by ';'. What is Elecraft-specific is the vocabulary
+// below, taken from the K3 Programmer's Reference; the K4 accepts the same set.
+//
+// NO K3 WAS AVAILABLE WHILE WRITING THIS, and that shapes it:
+//
+//   - The commands that SET something are the ones the reference documents
+//     unambiguously and whose effect is visible and reversible (PC, AG, TX/RX).
+//   - The meters are the opposite: their scaling differs between models and
+//     firmware, and a wrongly scaled SWR bar is worse than none — it reports a
+//     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.
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// KenwoodTXState is what the panel shows.
+type KenwoodTXState struct {
+	Available bool   `json:"available"`
+	Model     string `json:"model,omitempty"`
+	Elecraft  bool   `json:"elecraft"` // a K3/K4 rather than a Kenwood
+	Mode      string `json:"mode,omitempty"`
+
+	Transmitting bool  `json:"transmitting"`
+	Split        bool  `json:"split"`
+	SplitTXHz    int64 `json:"split_tx_hz"`
+
+	// SMeter is 0-100 for the bar. SMeterRaw is what the rig actually answered,
+	// kept because the scaling is not yet confirmed on a real K3 and a number
+	// nobody can check is worth less than the reading it came from.
+	SMeter    int `json:"s_meter"`
+	SMeterRaw int `json:"s_meter_raw"`
+	// PowerMeter is 0-100 while transmitting. SWR is the ratio; 0 means "not
+	// measured", NOT a perfect match.
+	PowerMeter int     `json:"power_meter"`
+	SWR        float64 `json:"swr"`
+	SWRRaw     int     `json:"swr_raw"`
+
+	RFPower int `json:"rf_power"` // watts, the PC setting
+	AFGain  int `json:"af_gain"`  // 0-100
+	RFGain  int `json:"rf_gain"`  // 0-100
+	MicGain int `json:"mic_gain"` // 0-100
+	Squelch int `json:"squelch"`  // 0-100
+
+	// Receive controls. Preamp and attenuator are the K3's single-step ones
+	// (PA/RA); a rig that answers neither leaves them false and the row shows
+	// the state it read, not a state it assumed.
+	Preamp bool   `json:"preamp"`
+	Att    bool   `json:"att"`
+	NB     bool   `json:"nb"`
+	NR     bool   `json:"nr"`
+	AGC    string `json:"agc,omitempty"` // "OFF", "SLOW", "FAST"
+	// FilterHz is the DSP bandwidth in Hz (the K3 reports it in 10 Hz units).
+	FilterHz int `json:"filter_hz"`
+	// Antenna is 1 or 2 on a K3 with the internal ATU, 0 when the rig does not
+	// answer AN — which is also how the panel knows to hide the row rather than
+	// offer a switch that goes nowhere.
+	Antenna int `json:"antenna"`
+
+	RIT bool `json:"rit"`
+	XIT bool `json:"xit"`
+	// 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
+	// measurement.
+	MetersProvisional bool `json:"meters_provisional"`
+}
+
+// KenwoodPanelController is the K3/K4 panel capability. Separate from
+// KenwoodController (the CW keyer) so a backend can offer one without the other.
+type KenwoodPanelController interface {
+	KenwoodState() KenwoodTXState
+	RefreshKenwood() error
+	SetKenwoodPower(int) error
+	SetKenwoodAFGain(int) error
+	SetKenwoodRFGain(int) error
+	SetKenwoodMicGain(int) error
+	SetKenwoodSquelch(int) error
+	SetKenwoodPreamp(bool) error
+	SetKenwoodAtt(bool) error
+	SetKenwoodNB(bool) error
+	SetKenwoodNR(bool) error
+	SetKenwoodAGC(string) error
+	SetKenwoodFilter(int) error
+	SetKenwoodAntenna(int) error
+	SetKenwoodRIT(bool) error
+	SetKenwoodXIT(bool) error
+	NudgeKenwoodRIT(int) error
+	ClearKenwoodRIT() error
+	SetKenwoodTX(bool) error
+	TuneKenwoodATU() error
+	ToggleKenwoodATU() error
+}
+
+// kenwoodPanelSlowBeat is how many polls pass between full re-reads of the
+// settings. The meters are read every poll; a power setting is not.
+const kenwoodPanelSlowBeat = 8
+
+// KenwoodState returns the panel snapshot.
+func (k *Kenwood) KenwoodState() KenwoodTXState {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	st := k.panel
+	st.Available = k.port != nil
+	st.Model = k.model
+	st.Elecraft = k.elecraft
+	return st
+}
+
+// RefreshKenwood forces the settings to be re-read on the next poll, so a value
+// changed on the radio's own front panel shows up at once.
+func (k *Kenwood) RefreshKenwood() error {
+	k.mu.Lock()
+	k.panelCycle = kenwoodPanelSlowBeat
+	k.mu.Unlock()
+	return nil
+}
+
+// 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, 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 || txNow
+	k.panel.MetersProvisional = true
+
+	if k.panel.Transmitting {
+		k.readTXMeters()
+	} else {
+		// Cleared, not frozen: a power bar left standing after the carrier drops
+		// reads as a live transmission.
+		k.panel.PowerMeter = 0
+		k.panel.SWR, k.panel.SWRRaw = 0, 0
+		k.powerPeak, k.swrPeak = meterPeak{}, meterPeak{}
+		// The S-meter only means anything while receiving.
+		if v, ok := k.askNum("SM;", "SM", 4); ok {
+			k.panel.SMeterRaw = v
+			k.panel.SMeter = kenwoodSMeterPercent(v)
+		}
+	}
+
+	k.panelCycle++
+	if k.panelLoaded && k.panelCycle < kenwoodPanelSlowBeat {
+		return
+	}
+	k.panelCycle = 0
+	k.panelLoaded = true
+	k.readPanelSettings()
+}
+
+// readPanelSettings re-reads what a knob can change.
+func (k *Kenwood) readPanelSettings() {
+	// PC is watts on both the K3 and the Kenwoods — a setting, not a scale.
+	if v, ok := k.askNum("PC;", "PC", 3); ok {
+		k.panel.RFPower = v
+	}
+	// AF gain. The K3 answers three digits 000-255; a Kenwood answers AG0nnn,
+	// which is why the plain form is tried first and the addressed one after.
+	if v, ok := k.askNum("AG;", "AG", 3); ok {
+		k.panel.AFGain = scale255(v)
+	} else if v, ok := k.askNum("AG0;", "AG0", 3); ok {
+		k.panel.AFGain = scale255(v)
+	}
+	// RF gain. The K3 counts 000-250 in dB of reduction; a Kenwood uses the
+	// familiar 0-255. Both are shown as a percentage, so the slider means the
+	// same thing on either radio.
+	if v, ok := k.askNum("RG;", "RG", 3); ok {
+		k.panel.RFGain = scalePercent(v, k.rfGainFull())
+	}
+	if v, ok := k.askNum("MG;", "MG", 3); ok {
+		k.panel.MicGain = scalePercent(v, k.micGainFull())
+	}
+	if v, ok := k.askNum("SQ;", "SQ", 3); ok {
+		k.panel.Squelch = scalePercent(v, k.squelchFull())
+	} else if v, ok := k.askNum("SQ0;", "SQ0", 3); ok {
+		k.panel.Squelch = scale255(v)
+	}
+	if v, ok := k.askNum("PA;", "PA", 1); ok {
+		k.panel.Preamp = v != 0
+	}
+	if v, ok := k.askNum("RA;", "RA", 2); ok {
+		k.panel.Att = v != 0
+	}
+	if v, ok := k.askNum("NB;", "NB", 1); ok {
+		k.panel.NB = v != 0
+	}
+	if v, ok := k.askNum("NR;", "NR", 1); ok {
+		k.panel.NR = v != 0
+	}
+	if v, ok := k.askNum("GT;", "GT", 3); ok {
+		k.panel.AGC = kenwoodAGCName(v)
+	}
+	// Filter width. The K3 answers BW in 10 Hz units (BW0270 = 2.7 kHz); a
+	// Kenwood that does not implement it says nothing and the row stays as it
+	// was rather than showing a zero-width filter.
+	if v, ok := k.askNum("BW;", "BW", 4); ok && v > 0 {
+		k.panel.FilterHz = v * 10
+	}
+	// Antenna. Only a K3 with the internal ATU answers; 0 means "this radio has
+	// no antenna switching", which is what hides the row.
+	if v, ok := k.askNum("AN;", "AN", 1); ok {
+		k.panel.Antenna = v
+	}
+	if v, ok := k.askNum("RT;", "RT", 1); ok {
+		k.panel.RIT = v != 0
+	}
+	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
+// a Kenwood, and using one rig's scale on the other silently halves or doubles
+// every setting. Kept as three small functions rather than a table so each one
+// carries the range it comes from.
+func (k *Kenwood) rfGainFull() int {
+	if k.elecraft {
+		return 250 // K3: 000-250, dB of reduction
+	}
+	return 255
+}
+
+func (k *Kenwood) micGainFull() int {
+	if k.elecraft {
+		return 60 // K3: 000-060
+	}
+	return 255
+}
+
+func (k *Kenwood) squelchFull() int {
+	if k.elecraft {
+		return 29 // K3: 000-029
+	}
+	return 255
+}
+
+// scalePercent turns a raw value into 0-100 against its own full scale.
+func scalePercent(v, full int) int {
+	if full <= 0 || v <= 0 {
+		return 0
+	}
+	if v >= full {
+		return 100
+	}
+	return v * 100 / full
+}
+
+// kenwoodAGCName decodes GT. The K3 answers 000 (off), 002 (slow) or 004
+// (fast); a Kenwood uses the same three values for the same three states.
+func kenwoodAGCName(v int) string {
+	switch {
+	case v == 0:
+		return "OFF"
+	case v <= 2:
+		return "SLOW"
+	default:
+		return "FAST"
+	}
+}
+
+// kenwoodAGCValue is the inverse, for the buttons.
+func kenwoodAGCValue(name string) int {
+	switch strings.ToUpper(strings.TrimSpace(name)) {
+	case "OFF":
+		return 0
+	case "SLOW":
+		return 2
+	default:
+		return 4
+	}
+}
+
+// kenwoodMeterProbes are the candidate meter commands, asked once per
+// transmission burst so a real radio can settle what they mean.
+//
+// They are NOT interchangeable — BG is a bargraph position, SM during transmit
+// is something else again — which is exactly why the log records which one
+// 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.
+// SW is no longer among them: it is known, read above, and asking again during
+// a transmission costs a round trip on the one link the carrier depends on.
+var kenwoodMeterProbes = []string{"SM;", "SMH;", "BG;", "PO;", "TQ;"}
+
+// 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)
+	}
+	// 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
+		if v > 0 {
+			k.panel.SWR = float64(k.swrPeak.update(v, now)) / 10
+		}
+	}
+	if k.metersLogged >= 20 {
+		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 _, cmd := range kenwoodMeterProbes {
+		if r, err := k.ask(cmd); err == nil {
+			raw = append(raw, strings.TrimSuffix(cmd, ";")+"→"+strings.TrimSuffix(r, ";"))
+		} else {
+			raw = append(raw, strings.TrimSuffix(cmd, ";")+"→refused")
+		}
+	}
+	debugLog.Printf("kenwood: TX meters at PC=%dW: %s (compare two power settings, and a known SWR)",
+		k.panel.RFPower, strings.Join(raw, " "))
+}
+
+// kenwoodSMeterPercent turns the S-meter answer into a bar percentage.
+//
+// The K3 reports 0-21 across S0…S9+60, which is not a linear dB scale but is
+// what its own display shows — and matching the radio's own bar is something an
+// operator can check at a glance. A Kenwood answers 0-30 on the same command;
+// both are covered by clamping rather than by guessing which rig is on the
+// other end.
+func kenwoodSMeterPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 30:
+		return 100
+	}
+	return v * 100 / 21
+}
+
+// kenwoodBargraphPercent scales the K3 bargraph (0-12 segments) to the bar.
+func kenwoodBargraphPercent(v int) int {
+	switch {
+	case v <= 0:
+		return 0
+	case v >= 12:
+		return 100
+	}
+	return v * 100 / 12
+}
+
+// SetKenwoodPower sets the transmit power, in watts.
+//
+// A K3 takes PC000-110: 110 rather than 100 because the radio will make a
+// little over its rated output and the reference says so. A Kenwood of the
+// TS-890 sort goes to 200, so the ceiling follows the radio rather than being
+// one number that is wrong for one of them.
+func (k *Kenwood) SetKenwoodPower(w int) error {
+	max := 200
+	if k.elecraft {
+		max = 110
+	}
+	if w < 0 {
+		w = 0
+	}
+	if w > max {
+		w = max
+	}
+	return k.setPanel(fmt.Sprintf("PC%03d;", w))
+}
+
+// SetKenwoodAFGain sets the volume, 0-100, scaled to the rig's 0-255.
+func (k *Kenwood) SetKenwoodAFGain(p int) error {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	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())))
+}
+
+func (k *Kenwood) SetKenwoodMicGain(p int) error {
+	return k.setPanel(fmt.Sprintf("MG%03d;", clampPercentTo(p, k.micGainFull())))
+}
+
+func (k *Kenwood) SetKenwoodSquelch(p int) error {
+	return k.setPanel(fmt.Sprintf("SQ%03d;", clampPercentTo(p, k.squelchFull())))
+}
+
+func (k *Kenwood) SetKenwoodPreamp(on bool) error {
+	return k.setPanel(fmt.Sprintf("PA%d;", boolDigit(on)))
+}
+
+// SetKenwoodAtt switches the attenuator. Two digits: the K3 reads RA01 as its
+// single 10 dB pad, and a Kenwood with several steps takes the first one.
+func (k *Kenwood) SetKenwoodAtt(on bool) error {
+	if on {
+		return k.setPanel("RA01;")
+	}
+	return k.setPanel("RA00;")
+}
+
+func (k *Kenwood) SetKenwoodNB(on bool) error {
+	return k.setPanel(fmt.Sprintf("NB%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodNR(on bool) error {
+	return k.setPanel(fmt.Sprintf("NR%d;", boolDigit(on)))
+}
+
+func (k *Kenwood) SetKenwoodAGC(name string) error {
+	return k.setPanel(fmt.Sprintf("GT%03d;", kenwoodAGCValue(name)))
+}
+
+// SetKenwoodFilter sets the DSP bandwidth in Hz — sent in the K3's 10 Hz units.
+func (k *Kenwood) SetKenwoodFilter(hz int) error {
+	if hz < 50 {
+		hz = 50
+	}
+	if hz > 4000 {
+		hz = 4000
+	}
+	return k.setPanel(fmt.Sprintf("BW%04d;", hz/10))
+}
+
+// SetKenwoodAntenna selects antenna 1 or 2 (a K3 with the internal ATU).
+func (k *Kenwood) SetKenwoodAntenna(n int) error {
+	if n < 1 {
+		n = 1
+	}
+	if n > 2 {
+		n = 2
+	}
+	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)))
+}
+
+func (k *Kenwood) SetKenwoodXIT(on bool) error {
+	return k.setPanel(fmt.Sprintf("XT%d;", boolDigit(on)))
+}
+
+// ClearKenwoodRIT zeroes the RIT/XIT offset, both at once — which is what RC
+// does and what the operator means by "clear it".
+func (k *Kenwood) ClearKenwoodRIT() error {
+	return k.setPanel("RC;")
+}
+
+// clampPercentTo maps 0-100 onto a rig's own full scale.
+func clampPercentTo(p, full int) int {
+	if p < 0 {
+		p = 0
+	}
+	if p > 100 {
+		p = 100
+	}
+	return p * full / 100
+}
+
+// SetKenwoodTX keys or unkeys the transmitter — the panel's MOX.
+//
+// Goes through SetPTT rather than writing TX;/RX; here, so the backend's own
+// idea of transmitting stays true: it suppresses polling while the carrier is
+// up, and a panel that keyed behind its back would leave it polling a rig that
+// answers "?;" to everything.
+func (k *Kenwood) SetKenwoodTX(on bool) error {
+	return k.SetPTT(on)
+}
+
+// The K3 has no dedicated "tune" command: the reference exposes the front panel
+// instead, through SWT (tap) and SWH (hold) with a switch number from Table 7.
+// Switch 19 is the ATU row — TAP starts a tuning cycle, HOLD puts the tuner in
+// or out of line.
+//
+// It was written as SWT20 first, from memory of the reference rather than from
+// the table, and 20 is not an ATU switch at all. Corrected against Table 7 of
+// the K3 Programmer's Reference, which an operator read out for us. Every send
+// is still logged: a switch-emulation command presses a real button on a real
+// front panel, so what OpsLog sent must be recoverable afterwards.
+const (
+	kenwoodATUTune   = "SWT19;" // tap ATU TUNE — start a tuning cycle
+	kenwoodATUToggle = "SWH19;" // hold ATU — tuner in line / bypassed
+)
+
+// TuneKenwoodATU starts an ATU tuning cycle.
+func (k *Kenwood) TuneKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU tune — sending %q (K3 Table 7: tap of the ATU TUNE switch)", kenwoodATUTune)
+	return k.setPanel(kenwoodATUTune)
+}
+
+// ToggleKenwoodATU puts the tuner in line or bypasses it — the HOLD of the same
+// switch, which is how it is done on the radio itself.
+func (k *Kenwood) ToggleKenwoodATU() error {
+	debugLog.Printf("kenwood: ATU in/out — sending %q (K3 Table 7: hold of the ATU switch)", kenwoodATUToggle)
+	return k.setPanel(kenwoodATUToggle)
+}
+
+// setPanel writes one command and schedules a settings re-read, so the panel
+// shows what the radio did rather than what it was asked to do.
+func (k *Kenwood) setPanel(cmd string) error {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	if k.port == nil {
+		return fmt.Errorf("kenwood: not connected")
+	}
+	if err := k.write(cmd); err != nil {
+		return err
+	}
+	k.panelCycle = kenwoodPanelSlowBeat // re-read on the next poll
+	return nil
+}
+
+// askNum asks a command and parses its numeric body. ask() already remembers
+// what this rig answered "?;" to and refuses to ask it again, so an unsupported
+// meter costs one timeout for the life of the session, not one per poll.
+func (k *Kenwood) askNum(cmd, prefix string, digits int) (int, bool) {
+	r, err := k.ask(cmd)
+	if err != nil {
+		return 0, false
+	}
+	body := strings.TrimSuffix(strings.TrimPrefix(r, prefix), ";")
+	if len(body) < digits {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(body[:digits]))
+	if err != nil {
+		return 0, false
+	}
+	return n, true
+}

internal/cat/tci.go

@@ -34,6 +34,16 @@ type TCI struct {
 	OnSpotClick   func(callsign string, freqHz int64)
 	unhandledSeen map[string]bool // log each unknown TCI message type once
 
+	// 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 +66,11 @@ 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
+	// 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)
@@ -341,6 +355,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 +370,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))
@@ -393,6 +417,16 @@ func (t *TCI) handle(msg string) {
 	switch strings.ToLower(name) {
 	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 +455,22 @@ func (t *TCI) handle(msg string) {
 		}
 	case "trx":
 		if get(0) == "0" {
+			was := t.tx
 			t.tx = get(1) == "true"
+			// Said out loud, every time. The transmit side of TCI can only be
+			// written from a log of a real transmission, and the first one came
+			// back without a single line to say whether the radio had even been
+			// keyed — which left the interesting question, why no transmit
+			// frames, indistinguishable from nobody having pressed anything.
+			if was != t.tx {
+				t.noteTXTransition(t.tx)
+			}
+		}
+	case "drive":
+		if get(0) == "0" {
+			if v, err := strconv.Atoi(get(1)); err == nil {
+				t.drive = v
+			}
 		}
 	case "tx_enable":
 		if get(0) == "0" {

internal/cat/tci_audio.go

@@ -0,0 +1,417 @@
+//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
+	}
+	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,39 @@
+//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)
+	})
+}

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,114 @@
+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 {
+		t.audio.mu.Lock()
+		t.audio.txShort++
+		t.audio.mu.Unlock()
+		return
+	}
+	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

@@ -43,7 +43,15 @@ type YaesuTXState struct {
 	PowerMeter int   `json:"power_meter"` // 0-100, TX only
 	SWRMeter   int   `json:"swr_meter"`   // 0-100, TX only
 
-	RFPower int    `json:"rf_power"` // watts
+	RFPower int `json:"rf_power"` // watts
+	// MaxPower is what this model can actually be set to, so the slider stops
+	// where the radio does. An FTDX101MP is a 200 W transmitter and its operator
+	// could not ask for more than 100 W — the slider, not the rig, was the limit.
+	MaxPower int `json:"max_power"`
+	// 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"`
 	MicGain int    `json:"mic_gain"` // 0-100
 	AFGain  int    `json:"af_gain"`  // 0-100
 	RFGain  int    `json:"rf_gain"`  // 0-100
@@ -110,9 +118,29 @@ func (y *Yaesu) YaesuState() YaesuTXState {
 	st := y.panel
 	st.Available = y.port != nil
 	st.Model = y.model
+	st.MaxPower = yaesuMaxPower(y.model, st.RFPower)
 	return st
 }
 
+// yaesuMaxPower is how far the power slider may go on this model.
+//
+// The rig itself is never asked — there is no CAT command for "how much power
+// can you make" — so it comes from the model name, with one safeguard: a rig
+// REPORTING more than the table expects is believed, because it has just proved
+// what it can do. Anything unknown gets 100 W, which is the family default and
+// errs towards asking for too little.
+func yaesuMaxPower(model string, reported int) int {
+	max := 100
+	switch {
+	case strings.Contains(model, "101MP"), strings.Contains(model, "5000"), strings.Contains(model, "9000"):
+		max = 200
+	}
+	if reported > max {
+		max = reported
+	}
+	return max
+}
+
 // readPanel refreshes the meters, and the settings on the slower beat. Called
 // from ReadState with the mutex HELD, so it shares the same serialised link.
 func (y *Yaesu) readPanel(mode string, split bool, txHz int64) {
@@ -226,8 +254,15 @@ func (y *Yaesu) readPanelSettings() {
 	if v, ok := y.askNum("PC;", "PC", 3); ok {
 		y.panel.RFPower = v // watts, not a 0-255 scale
 	}
+	// MIC GAIN IS 0-100, not 0-255.
+	//
+	// It was read through the 0-255 scale like the audio gains, so an FTDX101
+	// set to 80 showed 38 — and worse, writing sent 80 → 204, outside the range
+	// the rig accepts, so the setting was refused and the slider sprang back to
+	// where it had been. Reported from a real FTDX101; the CAT reference gives
+	// MG000-100 for the whole current family.
 	if v, ok := y.askNum("MG;", "MG", 3); ok {
-		y.panel.MicGain = scale255(v)
+		y.panel.MicGain = clampInt(v, 0, 100)
 	}
 	if v, ok := y.askNum("AG0;", "AG0", 3); ok {
 		y.panel.AFGain = scale255(v)
@@ -276,6 +311,7 @@ func (y *Yaesu) readPanelSettings() {
 	}
 	if v, ok := y.askNum("NA0;", "NA0", 1); ok {
 		y.panel.Narrow = v != 0
+		y.panel.NarrowSupported = true
 	}
 	if v, ok := y.askNum("VX;", "VX", 1); ok {
 		y.panel.VOX = v != 0
@@ -356,7 +392,7 @@ func (y *Yaesu) SetYaesuPower(w int) error {
 }
 
 func (y *Yaesu) SetYaesuMicGain(p int) error {
-	return y.setAndRefresh(fmt.Sprintf("MG%03d;", from100(p)))
+	return y.setAndRefresh(fmt.Sprintf("MG%03d;", clampInt(p, 0, 100)))
 }
 
 func (y *Yaesu) SetYaesuAFGain(p int) error {

internal/extsvc/lotw.go

@@ -265,6 +265,22 @@ func UploadLoTW(ctx context.Context, cfg ServiceConfig, tempDir, adifRecord stri
 	// callsign certificate's validity is silently left out, and reporting that as
 	// success stamped it sent for ever. TQSL says which case it is in its output,
 	// so the message is carried up rather than replaced with a guess.
+	if code != 0 && LogSink != nil {
+		// The ADIF that was handed to TQSL, verbatim, and how TQSL was called.
+		//
+		// TQSL says "no QSOs processed" for several unrelated reasons — already
+		// uploaded, outside the certificate's dates, or a STATION_CALLSIGN that
+		// does not match the station location it was told to sign with — and its
+		// message does not distinguish them. An operator whose contact was
+		// refused, then accepted after a round trip through another logger, is
+		// reporting a difference in THIS RECORD, and there is no way to see it
+		// afterwards: the temp file is deleted as soon as TQSL returns.
+		//
+		// Nothing secret here: it is a QSO, and the key password is not logged.
+		LogSink("lotw: tqsl exit %d for station location %q", code, loc)
+		LogSink("lotw: record was: %s", strings.TrimSpace(adifRecord))
+	}
+
 	switch code {
 	case 0:
 		return UploadResult{OK: true, Message: "uploaded to LoTW"}, nil

internal/integrations/udp/instances_test.go

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

internal/integrations/udp/server.go

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

internal/powergenius/operate_test.go

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

internal/powergenius/powergenius.go

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

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 {

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.9"
+	appVersion = "0.26.15"
 
 	// 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, " | ")
+}